blob: f5d98b917dc9e18e531b7761d03bc54ed6774352 [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glass59d66d22015-03-25 12:22:37 -06002/*
3 * (C) Copyright 2015 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
Simon Glass59d66d22015-03-25 12:22:37 -06005 */
6
7#include <common.h>
8#include <dm.h>
Simon Glass0f2af882020-05-10 11:40:05 -06009#include <log.h>
Simon Glass59d66d22015-03-25 12:22:37 -060010#include <usb.h>
Simon Glass59d66d22015-03-25 12:22:37 -060011#include <dm/device-internal.h>
12
Simon Glass59d66d22015-03-25 12:22:37 -060013static int copy_to_unicode(char *buff, int length, const char *str)
14{
15 int ptr;
16 int i;
17
18 if (length < 2)
19 return 0;
20 buff[1] = USB_DT_STRING;
21 for (ptr = 2, i = 0; ptr + 1 < length && *str; i++, ptr += 2) {
22 buff[ptr] = str[i];
23 buff[ptr + 1] = 0;
24 }
25 buff[0] = ptr;
26
27 return ptr;
28}
29
30static int usb_emul_get_string(struct usb_string *strings, int index,
31 char *buff, int length)
32{
33 if (index == 0) {
34 char *desc = buff;
35
36 desc[0] = 4;
37 desc[1] = USB_DT_STRING;
38 desc[2] = 0x09;
39 desc[3] = 0x14;
40 return 4;
41 } else if (strings) {
42 struct usb_string *ptr;
43
44 for (ptr = strings; ptr->s; ptr++) {
45 if (ptr->id == index)
46 return copy_to_unicode(buff, length, ptr->s);
47 }
48 }
49
50 return -EINVAL;
51}
52
Bin Meng3b363762017-10-01 06:19:40 -070053struct usb_generic_descriptor **usb_emul_find_descriptor(
Simon Glass59d66d22015-03-25 12:22:37 -060054 struct usb_generic_descriptor **ptr, int type, int index)
55{
56 debug("%s: type=%x, index=%d\n", __func__, type, index);
57 for (; *ptr; ptr++) {
58 if ((*ptr)->bDescriptorType != type)
59 continue;
60 switch (type) {
61 case USB_DT_CONFIG: {
62 struct usb_config_descriptor *cdesc;
63
64 cdesc = (struct usb_config_descriptor *)*ptr;
65 if (cdesc && cdesc->bConfigurationValue == index)
66 return ptr;
67 break;
68 }
69 default:
70 return ptr;
71 }
72 }
73 debug("%s: config ptr=%p\n", __func__, *ptr);
74
75 return ptr;
76}
77
Simon Glassb75b15b2020-12-03 16:55:23 -070078static int usb_emul_get_descriptor(struct usb_dev_plat *plat, int value,
Simon Glass59d66d22015-03-25 12:22:37 -060079 void *buffer, int length)
80{
81 struct usb_generic_descriptor **ptr;
82 int type = value >> 8;
83 int index = value & 0xff;
84 int upto, todo;
85
86 debug("%s: type=%d, index=%d, plat=%p\n", __func__, type, index, plat);
87 if (type == USB_DT_STRING) {
88 return usb_emul_get_string(plat->strings, index, buffer,
89 length);
90 }
91
Bin Meng3b363762017-10-01 06:19:40 -070092 ptr = usb_emul_find_descriptor(plat->desc_list, type, index);
Simon Glass59d66d22015-03-25 12:22:37 -060093 if (!ptr) {
94 debug("%s: Could not find descriptor type %d, index %d\n",
95 __func__, type, index);
96 return -ENOENT;
97 }
98 for (upto = 0; *ptr && upto < length; ptr++, upto += todo) {
99 todo = min(length - upto, (int)(*ptr)->bLength);
100
101 memcpy(buffer + upto, *ptr, todo);
102 }
103
104 return upto ? upto : length ? -EIO : 0;
105}
106
Bin Mengf1966442017-10-01 06:19:39 -0700107static int usb_emul_find_devnum(int devnum, int port1, struct udevice **emulp)
Simon Glass59d66d22015-03-25 12:22:37 -0600108{
Simon Glass59d66d22015-03-25 12:22:37 -0600109 struct udevice *dev;
110 struct uclass *uc;
111 int ret;
112
113 *emulp = NULL;
114 ret = uclass_get(UCLASS_USB_EMUL, &uc);
115 if (ret)
116 return ret;
117 uclass_foreach_dev(dev, uc) {
Simon Glassb75b15b2020-12-03 16:55:23 -0700118 struct usb_dev_plat *udev = dev_get_parent_plat(dev);
Simon Glass59d66d22015-03-25 12:22:37 -0600119
Bin Mengf1966442017-10-01 06:19:39 -0700120 /*
121 * devnum is initialzied to zero at the beginning of the
122 * enumeration process in usb_setup_device(). At this
123 * point, udev->devnum has not been assigned to any valid
124 * USB address either, so we can't rely on the comparison
125 * result between udev->devnum and devnum to select an
126 * emulator device.
127 */
128 if (!devnum) {
Simon Glassb75b15b2020-12-03 16:55:23 -0700129 struct usb_emul_plat *plat;
Bin Mengf1966442017-10-01 06:19:39 -0700130
131 /*
132 * If the parent is sandbox USB controller, we are
133 * the root hub. And there is only one root hub
134 * in the system.
135 */
136 if (device_get_uclass_id(dev->parent) == UCLASS_USB) {
137 debug("%s: Found emulator '%s'\n",
138 __func__, dev->name);
139 *emulp = dev;
140 return 0;
141 }
142
Simon Glass71fa5b42020-12-03 16:55:18 -0700143 plat = dev_get_uclass_plat(dev);
Bin Mengf1966442017-10-01 06:19:39 -0700144 if (plat->port1 == port1) {
145 debug("%s: Found emulator '%s', port %d\n",
146 __func__, dev->name, port1);
147 *emulp = dev;
148 return 0;
149 }
150 } else if (udev->devnum == devnum) {
Simon Glass59d66d22015-03-25 12:22:37 -0600151 debug("%s: Found emulator '%s', addr %d\n", __func__,
152 dev->name, udev->devnum);
153 *emulp = dev;
154 return 0;
155 }
156 }
157
158 debug("%s: No emulator found, addr %d\n", __func__, devnum);
159 return -ENOENT;
160}
161
Bin Mengf1966442017-10-01 06:19:39 -0700162int usb_emul_find(struct udevice *bus, ulong pipe, int port1,
163 struct udevice **emulp)
Simon Glass668ef3d2015-11-08 23:47:55 -0700164{
165 int devnum = usb_pipedevice(pipe);
166
Bin Mengf1966442017-10-01 06:19:39 -0700167 return usb_emul_find_devnum(devnum, port1, emulp);
Simon Glass668ef3d2015-11-08 23:47:55 -0700168}
169
170int usb_emul_find_for_dev(struct udevice *dev, struct udevice **emulp)
171{
Simon Glassb75b15b2020-12-03 16:55:23 -0700172 struct usb_dev_plat *udev = dev_get_parent_plat(dev);
Simon Glass668ef3d2015-11-08 23:47:55 -0700173
Bin Mengf1966442017-10-01 06:19:39 -0700174 return usb_emul_find_devnum(udev->devnum, 0, emulp);
Simon Glass668ef3d2015-11-08 23:47:55 -0700175}
176
Simon Glass59d66d22015-03-25 12:22:37 -0600177int usb_emul_control(struct udevice *emul, struct usb_device *udev,
178 unsigned long pipe, void *buffer, int length,
179 struct devrequest *setup)
180{
181 struct dm_usb_ops *ops = usb_get_emul_ops(emul);
Simon Glassb75b15b2020-12-03 16:55:23 -0700182 struct usb_dev_plat *plat;
Simon Glass59d66d22015-03-25 12:22:37 -0600183 int ret;
184
185 /* We permit getting the descriptor before we are probed */
Simon Glass71fa5b42020-12-03 16:55:18 -0700186 plat = dev_get_parent_plat(emul);
Simon Glass59d66d22015-03-25 12:22:37 -0600187 if (!ops->control)
188 return -ENOSYS;
189 debug("%s: dev=%s\n", __func__, emul->name);
190 if (pipe == usb_rcvctrlpipe(udev, 0)) {
191 switch (setup->request) {
192 case USB_REQ_GET_DESCRIPTOR: {
193 return usb_emul_get_descriptor(plat, setup->value,
194 buffer, length);
195 }
196 default:
197 ret = device_probe(emul);
198 if (ret)
199 return ret;
200 return ops->control(emul, udev, pipe, buffer, length,
201 setup);
202 }
203 } else if (pipe == usb_snddefctrl(udev)) {
204 switch (setup->request) {
205 case USB_REQ_SET_ADDRESS:
206 debug(" ** set address %s %d\n", emul->name,
207 setup->value);
208 plat->devnum = setup->value;
209 return 0;
210 default:
211 debug("requestsend =%x\n", setup->request);
212 break;
213 }
214 } else if (pipe == usb_sndctrlpipe(udev, 0)) {
215 switch (setup->request) {
216 case USB_REQ_SET_CONFIGURATION:
217 plat->configno = setup->value;
218 return 0;
219 default:
220 ret = device_probe(emul);
221 if (ret)
222 return ret;
223 return ops->control(emul, udev, pipe, buffer, length,
224 setup);
225 }
226 }
227 debug("pipe=%lx\n", pipe);
228
229 return -EIO;
230}
231
232int usb_emul_bulk(struct udevice *emul, struct usb_device *udev,
233 unsigned long pipe, void *buffer, int length)
234{
235 struct dm_usb_ops *ops = usb_get_emul_ops(emul);
236 int ret;
237
238 /* We permit getting the descriptor before we are probed */
239 if (!ops->bulk)
240 return -ENOSYS;
241 debug("%s: dev=%s\n", __func__, emul->name);
242 ret = device_probe(emul);
243 if (ret)
244 return ret;
245 return ops->bulk(emul, udev, pipe, buffer, length);
246}
247
Simon Glass90421792015-11-08 23:48:05 -0700248int usb_emul_int(struct udevice *emul, struct usb_device *udev,
Michal Suchanek1c95b9f2019-08-18 10:55:27 +0200249 unsigned long pipe, void *buffer, int length, int interval,
250 bool nonblock)
Simon Glass90421792015-11-08 23:48:05 -0700251{
252 struct dm_usb_ops *ops = usb_get_emul_ops(emul);
253
254 if (!ops->interrupt)
255 return -ENOSYS;
256 debug("%s: dev=%s\n", __func__, emul->name);
257
Michal Suchanek1c95b9f2019-08-18 10:55:27 +0200258 return ops->interrupt(emul, udev, pipe, buffer, length, interval,
259 nonblock);
Simon Glass90421792015-11-08 23:48:05 -0700260}
261
Bin Mengd502cf12017-10-01 06:19:36 -0700262int usb_emul_setup_device(struct udevice *dev, struct usb_string *strings,
263 void **desc_list)
Simon Glass59d66d22015-03-25 12:22:37 -0600264{
Simon Glassb75b15b2020-12-03 16:55:23 -0700265 struct usb_dev_plat *plat = dev_get_parent_plat(dev);
Simon Glass59d66d22015-03-25 12:22:37 -0600266 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
Simon Glass59d66d22015-03-25 12:22:37 -0600297UCLASS_DRIVER(usb_emul) = {
298 .id = UCLASS_USB_EMUL,
299 .name = "usb_emul",
Simon Glass18230342016-07-05 17:10:10 -0600300 .post_bind = dm_scan_fdt_dev,
Simon Glassb75b15b2020-12-03 16:55:23 -0700301 .per_device_plat_auto = sizeof(struct usb_emul_plat),
Simon Glass8a2b47f2020-12-03 16:55:17 -0700302 .per_child_auto = sizeof(struct usb_device),
Simon Glassb75b15b2020-12-03 16:55:23 -0700303 .per_child_plat_auto = sizeof(struct usb_dev_plat),
Simon Glass59d66d22015-03-25 12:22:37 -0600304};