1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/* Regression test for state explosion seen whilst implementing
PR analyzer/110426, involving an explosion in the number of
conjured_svalues whilst handling a long chain of external
function calls. */
/* { dg-additional-options "-Wno-implicit-function-declaration -Wno-int-conversion -Wno-analyzer-too-complex" } */
#define NULL ((void *)0)
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
typedef struct Error Error;
typedef struct QEMUTimer QEMUTimer;
enum libusb_class_code {
LIBUSB_CLASS_PER_INTERFACE = 0x00,
};
struct libusb_device_descriptor {};
struct libusb_endpoint_descriptor {
uint8_t bEndpointAddress;
uint8_t bmAttributes;
};
struct libusb_interface_descriptor {
uint8_t bNumEndpoints;
const struct libusb_endpoint_descriptor *endpoint;
};
struct libusb_interface {
const struct libusb_interface_descriptor *altsetting;
};
struct libusb_config_descriptor {
uint8_t bNumInterfaces;
const struct libusb_interface *interface;
};
typedef struct libusb_context libusb_context;
typedef struct libusb_device libusb_device;
typedef struct libusb_device_handle libusb_device_handle;
enum libusb_speed {
LIBUSB_SUCCESS = 0,
LIBUSB_TRANSFER_TYPE_BULK = 2U,
};
typedef struct USBDevice USBDevice;
typedef struct USBHostDevice USBHostDevice;
struct USBAutoFilter {
uint32_t bus_num;
};
struct USBHostDevice {
struct USBAutoFilter match;
struct USBHostDevice *tqe_next;
int bus_num;
int addr;
char port[16];
libusb_device *dev;
libusb_device_handle *dh;
struct libusb_device_descriptor ddesc;
};
static union { struct USBHostDevice *tqh_first; } hostdevs = {};
static libusb_context *ctx;
static void usb_host_ep_update(USBHostDevice *s) {
static const char *tname[] = {};
USBDevice *udev = USB_DEVICE(s);
struct libusb_config_descriptor *conf;
const struct libusb_interface_descriptor *intf;
const struct libusb_endpoint_descriptor *endp;
struct libusb_ss_endpoint_companion_descriptor *endp_ss_comp;
uint8_t devep, type;
int ep;
int rc, i, e;
usb_ep_reset(udev);
rc = libusb_get_active_config_descriptor(s->dev, &conf);
for (i = 0; i < conf->bNumInterfaces; i++) {
intf = &conf->interface[i].altsetting[0];
trace_usb_host_parse_interface();
for (e = 0; e < intf->bNumEndpoints; e++) {
endp = &intf->endpoint[e];
devep = endp->bEndpointAddress;
ep = devep & 0xf;
type = endp->bmAttributes & 0x3;
if (usb_ep_get_type(udev) != 255) {
trace_usb_host_parse_error();
}
trace_usb_host_parse_endpoint(s->bus_num, s->addr);
usb_ep_set_max_packet_size(udev);
usb_ep_set_type(udev);
usb_ep_set_ifnum(udev);
usb_ep_set_halted(udev);
if (type == LIBUSB_TRANSFER_TYPE_BULK &&
libusb_get_ss_endpoint_companion_descriptor(
ctx, endp, &endp_ss_comp) == LIBUSB_SUCCESS) {
usb_ep_set_max_streams(udev);
libusb_free_ss_endpoint_companion_descriptor(endp_ss_comp);
}
}
}
}
static int usb_host_open(USBHostDevice *s, libusb_device *dev, int hostfd) {
USBDevice *udev = USB_DEVICE(s);
int bus_num = 0;
int addr = 0;
Error *local_err = NULL;
if (dev) {
bus_num = libusb_get_bus_number(dev);
addr = libusb_get_device_address(dev);
trace_usb_host_open_started(bus_num, addr);
libusb_open(dev, &s->dh);
trace_usb_host_open_hostfd(hostfd);
libusb_wrap_sys_device(ctx, &s->dh);
dev = libusb_get_device(s->dh);
bus_num = libusb_get_bus_number(dev);
addr = libusb_get_device_address(dev);
}
usb_host_detach_kernel(s);
libusb_get_device_descriptor(dev, &s->ddesc);
usb_host_get_port(s->dev, s->port, sizeof(s->port));
usb_ep_init(udev);
usb_host_ep_update(s);
libusb_get_device_speed(dev);
usb_device_attach(udev, &local_err);
if (local_err) {
error_report_err(local_err);
goto fail;
}
return 0;
fail:
trace_usb_host_open_failure();
if (s->dh != NULL) {
usb_host_release_interfaces(s);
libusb_reset_device(s->dh);
usb_host_attach_kernel(s);
}
}
static QEMUTimer *usb_auto_timer;
static void usb_host_vm_state(void *unused, _Bool running) {}
static void usb_host_auto_check(void *unused) {
struct USBHostDevice *s;
struct USBAutoFilter *f;
libusb_device **devs = NULL;
struct libusb_device_descriptor ddesc;
int i, n;
if (usb_host_init() != 0) {
n = libusb_get_device_list(ctx, &devs);
for (i = 0; i < n; i++) {
if (libusb_get_device_descriptor(devs[i], &ddesc) != 0) {
}
for ((s) = ((&hostdevs)->tqh_first); (s); (s) = ((s)->tqe_next)) {
f = &s->match;
if (f->bus_num > 0 && f->bus_num != libusb_get_bus_number(devs[i])) {
}
if (usb_host_open(s, devs[i], 0) < 0) {
}
}
}
libusb_free_device_list(devs, 1);
qemu_add_vm_change_state_handler(usb_host_vm_state, NULL);
timer_new_ms(usb_host_auto_check, NULL);
trace_usb_host_auto_scan_enabled();
}
timer_mod(usb_auto_timer, qemu_clock_get_ms() + 2000);
}
|
