]> git.sur5r.net Git - u-boot/blob - drivers/usb/host/usb-sandbox.c
usb: sunxi: ehci: get rid of ifdefs
[u-boot] / drivers / usb / host / usb-sandbox.c
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 <usb.h>
10 #include <dm/root.h>
11
12 struct sandbox_usb_ctrl {
13         int rootdev;
14 };
15
16 static void usbmon_trace(struct udevice *bus, ulong pipe,
17                          struct devrequest *setup, struct udevice *emul)
18 {
19         static const char types[] = "ZICB";
20         int type;
21
22         type = (pipe & USB_PIPE_TYPE_MASK) >> USB_PIPE_TYPE_SHIFT;
23         debug("0 0 S %c%c:%d:%03ld:%ld", types[type],
24               pipe & USB_DIR_IN ? 'i' : 'o',
25               bus->seq,
26               (pipe & USB_PIPE_DEV_MASK) >> USB_PIPE_DEV_SHIFT,
27               (pipe & USB_PIPE_EP_MASK) >> USB_PIPE_EP_SHIFT);
28         if (setup) {
29                 debug(" s %02x %02x %04x %04x %04x", setup->requesttype,
30                       setup->request, setup->value, setup->index,
31                       setup->length);
32         }
33         debug(" %s", emul ? emul->name : "(no emul found)");
34
35         debug("\n");
36 }
37
38 static int sandbox_submit_control(struct udevice *bus,
39                                       struct usb_device *udev,
40                                       unsigned long pipe,
41                                       void *buffer, int length,
42                                       struct devrequest *setup)
43 {
44         struct sandbox_usb_ctrl *ctrl = dev_get_priv(bus);
45         struct udevice *emul;
46         int ret;
47
48         /* Just use child of dev as emulator? */
49         debug("%s: bus=%s\n", __func__, bus->name);
50         ret = usb_emul_find(bus, pipe, udev->portnr, &emul);
51         usbmon_trace(bus, pipe, setup, emul);
52         if (ret)
53                 return ret;
54
55         if (usb_pipedevice(pipe) == ctrl->rootdev) {
56                 if (setup->request == USB_REQ_SET_ADDRESS) {
57                         debug("%s: Set root hub's USB address\n", __func__);
58                         ctrl->rootdev = le16_to_cpu(setup->value);
59                 }
60         }
61
62         ret = usb_emul_control(emul, udev, pipe, buffer, length, setup);
63         if (ret < 0) {
64                 debug("ret=%d\n", ret);
65                 udev->status = ret;
66                 udev->act_len = 0;
67         } else {
68                 udev->status = 0;
69                 udev->act_len = ret;
70         }
71
72         return ret;
73 }
74
75 static int sandbox_submit_bulk(struct udevice *bus, struct usb_device *udev,
76                                unsigned long pipe, void *buffer, int length)
77 {
78         struct udevice *emul;
79         int ret;
80
81         /* Just use child of dev as emulator? */
82         debug("%s: bus=%s\n", __func__, bus->name);
83         ret = usb_emul_find(bus, pipe, udev->portnr, &emul);
84         usbmon_trace(bus, pipe, NULL, emul);
85         if (ret)
86                 return ret;
87         ret = usb_emul_bulk(emul, udev, pipe, buffer, length);
88         if (ret < 0) {
89                 debug("ret=%d\n", ret);
90                 udev->status = ret;
91                 udev->act_len = 0;
92         } else {
93                 udev->status = 0;
94                 udev->act_len = ret;
95         }
96
97         return ret;
98 }
99
100 static int sandbox_submit_int(struct udevice *bus, struct usb_device *udev,
101                               unsigned long pipe, void *buffer, int length,
102                               int interval)
103 {
104         struct udevice *emul;
105         int ret;
106
107         /* Just use child of dev as emulator? */
108         debug("%s: bus=%s\n", __func__, bus->name);
109         ret = usb_emul_find(bus, pipe, udev->portnr, &emul);
110         usbmon_trace(bus, pipe, NULL, emul);
111         if (ret)
112                 return ret;
113         ret = usb_emul_int(emul, udev, pipe, buffer, length, interval);
114
115         return ret;
116 }
117
118 static int sandbox_alloc_device(struct udevice *dev, struct usb_device *udev)
119 {
120         struct sandbox_usb_ctrl *ctrl = dev_get_priv(dev);
121
122         /*
123          * Root hub will be the first device to be initailized.
124          * If this device is a root hub, initialize its device speed
125          * to high speed as we are a USB 2.0 controller.
126          */
127         if (ctrl->rootdev == 0)
128                 udev->speed = USB_SPEED_HIGH;
129
130         return 0;
131 }
132
133 static int sandbox_usb_probe(struct udevice *dev)
134 {
135         return 0;
136 }
137
138 static const struct dm_usb_ops sandbox_usb_ops = {
139         .control        = sandbox_submit_control,
140         .bulk           = sandbox_submit_bulk,
141         .interrupt      = sandbox_submit_int,
142         .alloc_device   = sandbox_alloc_device,
143 };
144
145 static const struct udevice_id sandbox_usb_ids[] = {
146         { .compatible = "sandbox,usb" },
147         { }
148 };
149
150 U_BOOT_DRIVER(usb_sandbox) = {
151         .name   = "usb_sandbox",
152         .id     = UCLASS_USB,
153         .of_match = sandbox_usb_ids,
154         .probe = sandbox_usb_probe,
155         .ops    = &sandbox_usb_ops,
156         .priv_auto_alloc_size = sizeof(struct sandbox_usb_ctrl),
157 };