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/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 55 struct usb_generic_descriptor **usb_emul_find_descriptor( 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 94 ptr = usb_emul_find_descriptor(plat->desc_list, type, index); 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 109 static int usb_emul_find_devnum(int devnum, int port1, struct udevice **emulp) 110 { 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 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) { 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 164 int usb_emul_find(struct udevice *bus, ulong pipe, int port1, 165 struct udevice **emulp) 166 { 167 int devnum = usb_pipedevice(pipe); 168 169 return usb_emul_find_devnum(devnum, port1, emulp); 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 176 return usb_emul_find_devnum(udev->devnum, 0, emulp); 177 } 178 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 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 262 int usb_emul_setup_device(struct udevice *dev, struct usb_string *strings, 263 void **desc_list) 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 297 UCLASS_DRIVER(usb_emul) = { 298 .id = UCLASS_USB_EMUL, 299 .name = "usb_emul", 300 .post_bind = dm_scan_fdt_dev, 301 .per_device_platdata_auto_alloc_size = sizeof(struct usb_emul_platdata), 302 .per_child_auto_alloc_size = sizeof(struct usb_device), 303 .per_child_platdata_auto_alloc_size = sizeof(struct usb_dev_platdata), 304 }; 305