1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * (C) Copyright 2015 Google, Inc 4 * Written by Simon Glass <sjg@chromium.org> 5 */ 6 7#include <common.h> 8#include <dm.h> 9#include <log.h> 10#include <usb.h> 11#include <dm/root.h> 12#include <linux/usb/gadget.h> 13 14struct sandbox_udc { 15 struct usb_gadget gadget; 16}; 17 18struct sandbox_udc *this_controller; 19 20struct sandbox_usb_ctrl { 21 int rootdev; 22}; 23 24static void usbmon_trace(struct udevice *bus, ulong pipe, 25 struct devrequest *setup, struct udevice *emul) 26{ 27 static const char types[] = "ZICB"; 28 int type; 29 30 type = (pipe & USB_PIPE_TYPE_MASK) >> USB_PIPE_TYPE_SHIFT; 31 debug("0 0 S %c%c:%d:%03ld:%ld", types[type], 32 pipe & USB_DIR_IN ? 'i' : 'o', 33 dev_seq(bus), 34 (pipe & USB_PIPE_DEV_MASK) >> USB_PIPE_DEV_SHIFT, 35 (pipe & USB_PIPE_EP_MASK) >> USB_PIPE_EP_SHIFT); 36 if (setup) { 37 debug(" s %02x %02x %04x %04x %04x", setup->requesttype, 38 setup->request, setup->value, setup->index, 39 setup->length); 40 } 41 debug(" %s", emul ? emul->name : "(no emul found)"); 42 43 debug("\n"); 44} 45 46static int sandbox_submit_control(struct udevice *bus, 47 struct usb_device *udev, 48 unsigned long pipe, 49 void *buffer, int length, 50 struct devrequest *setup) 51{ 52 struct sandbox_usb_ctrl *ctrl = dev_get_priv(bus); 53 struct udevice *emul; 54 int ret; 55 56 /* Just use child of dev as emulator? */ 57 debug("%s: bus=%s\n", __func__, bus->name); 58 ret = usb_emul_find(bus, pipe, udev->portnr, &emul); 59 usbmon_trace(bus, pipe, setup, emul); 60 if (ret) 61 return ret; 62 63 if (usb_pipedevice(pipe) == ctrl->rootdev) { 64 if (setup->request == USB_REQ_SET_ADDRESS) { 65 debug("%s: Set root hub's USB address\n", __func__); 66 ctrl->rootdev = le16_to_cpu(setup->value); 67 } 68 } 69 70 ret = usb_emul_control(emul, udev, pipe, buffer, length, setup); 71 if (ret < 0) { 72 debug("ret=%d\n", ret); 73 udev->status = ret; 74 udev->act_len = 0; 75 } else { 76 udev->status = 0; 77 udev->act_len = ret; 78 } 79 80 return ret; 81} 82 83static int sandbox_submit_bulk(struct udevice *bus, struct usb_device *udev, 84 unsigned long pipe, void *buffer, int length) 85{ 86 struct udevice *emul; 87 int ret; 88 89 /* Just use child of dev as emulator? */ 90 debug("%s: bus=%s\n", __func__, bus->name); 91 ret = usb_emul_find(bus, pipe, udev->portnr, &emul); 92 usbmon_trace(bus, pipe, NULL, emul); 93 if (ret) 94 return ret; 95 ret = usb_emul_bulk(emul, udev, pipe, buffer, length); 96 if (ret < 0) { 97 debug("ret=%d\n", ret); 98 udev->status = ret; 99 udev->act_len = 0; 100 } else { 101 udev->status = 0; 102 udev->act_len = ret; 103 } 104 105 return ret; 106} 107 108static int sandbox_submit_int(struct udevice *bus, struct usb_device *udev, 109 unsigned long pipe, void *buffer, int length, 110 int interval, bool nonblock) 111{ 112 struct udevice *emul; 113 int ret; 114 115 /* Just use child of dev as emulator? */ 116 debug("%s: bus=%s\n", __func__, bus->name); 117 ret = usb_emul_find(bus, pipe, udev->portnr, &emul); 118 usbmon_trace(bus, pipe, NULL, emul); 119 if (ret) 120 return ret; 121 ret = usb_emul_int(emul, udev, pipe, buffer, length, interval, 122 nonblock); 123 124 return ret; 125} 126 127#if CONFIG_IS_ENABLED(DM_USB_GADGET) 128int dm_usb_gadget_handle_interrupts(struct udevice *dev) 129{ 130 return 0; 131} 132#else 133int usb_gadget_register_driver(struct usb_gadget_driver *driver) 134{ 135 struct sandbox_udc *dev = this_controller; 136 137 return driver->bind(&dev->gadget); 138} 139 140int usb_gadget_unregister_driver(struct usb_gadget_driver *driver) 141{ 142 struct sandbox_udc *dev = this_controller; 143 144 driver->unbind(&dev->gadget); 145 146 return 0; 147} 148#endif 149 150static int sandbox_alloc_device(struct udevice *dev, struct usb_device *udev) 151{ 152 struct sandbox_usb_ctrl *ctrl = dev_get_priv(dev); 153 154 /* 155 * Root hub will be the first device to be initailized. 156 * If this device is a root hub, initialize its device speed 157 * to high speed as we are a USB 2.0 controller. 158 */ 159 if (ctrl->rootdev == 0) 160 udev->speed = USB_SPEED_HIGH; 161 162 return 0; 163} 164 165static int sandbox_usb_probe(struct udevice *dev) 166{ 167 return 0; 168} 169 170static const struct dm_usb_ops sandbox_usb_ops = { 171 .control = sandbox_submit_control, 172 .bulk = sandbox_submit_bulk, 173 .interrupt = sandbox_submit_int, 174 .alloc_device = sandbox_alloc_device, 175}; 176 177static const struct udevice_id sandbox_usb_ids[] = { 178 { .compatible = "sandbox,usb" }, 179 { } 180}; 181 182U_BOOT_DRIVER(usb_sandbox) = { 183 .name = "usb_sandbox", 184 .id = UCLASS_USB, 185 .of_match = sandbox_usb_ids, 186 .probe = sandbox_usb_probe, 187 .ops = &sandbox_usb_ops, 188 .priv_auto = sizeof(struct sandbox_usb_ctrl), 189}; 190