1#include "hw/usb.h"
2#include "hw/usb/desc.h"
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
34typedef struct msos_compat_hdr {
35 uint32_t dwLength;
36 uint8_t bcdVersion_lo;
37 uint8_t bcdVersion_hi;
38 uint8_t wIndex_lo;
39 uint8_t wIndex_hi;
40 uint8_t bCount;
41 uint8_t reserved[7];
42} QEMU_PACKED msos_compat_hdr;
43
44typedef struct msos_compat_func {
45 uint8_t bFirstInterfaceNumber;
46 uint8_t reserved_1;
47 char compatibleId[8];
48 uint8_t subCompatibleId[8];
49 uint8_t reserved_2[6];
50} QEMU_PACKED msos_compat_func;
51
52static int usb_desc_msos_compat(const USBDesc *desc, uint8_t *dest)
53{
54 msos_compat_hdr *hdr = (void *)dest;
55 msos_compat_func *func;
56 int length = sizeof(*hdr);
57 int count = 0;
58
59 func = (void *)(dest + length);
60 func->bFirstInterfaceNumber = 0;
61 func->reserved_1 = 0x01;
62 if (desc->msos->CompatibleID) {
63 snprintf(func->compatibleId, sizeof(func->compatibleId),
64 "%s", desc->msos->CompatibleID);
65 }
66 length += sizeof(*func);
67 count++;
68
69 hdr->dwLength = cpu_to_le32(length);
70 hdr->bcdVersion_lo = 0x00;
71 hdr->bcdVersion_hi = 0x01;
72 hdr->wIndex_lo = 0x04;
73 hdr->wIndex_hi = 0x00;
74 hdr->bCount = count;
75 return length;
76}
77
78
79
80typedef struct msos_prop_hdr {
81 uint32_t dwLength;
82 uint8_t bcdVersion_lo;
83 uint8_t bcdVersion_hi;
84 uint8_t wIndex_lo;
85 uint8_t wIndex_hi;
86 uint8_t wCount_lo;
87 uint8_t wCount_hi;
88} QEMU_PACKED msos_prop_hdr;
89
90typedef struct msos_prop {
91 uint32_t dwLength;
92 uint32_t dwPropertyDataType;
93 uint8_t dwPropertyNameLength_lo;
94 uint8_t dwPropertyNameLength_hi;
95 uint8_t bPropertyName[];
96} QEMU_PACKED msos_prop;
97
98typedef struct msos_prop_data {
99 uint32_t dwPropertyDataLength;
100 uint8_t bPropertyData[];
101} QEMU_PACKED msos_prop_data;
102
103typedef enum msos_prop_type {
104 MSOS_REG_SZ = 1,
105 MSOS_REG_EXPAND_SZ = 2,
106 MSOS_REG_BINARY = 3,
107 MSOS_REG_DWORD_LE = 4,
108 MSOS_REG_DWORD_BE = 5,
109 MSOS_REG_LINK = 6,
110 MSOS_REG_MULTI_SZ = 7,
111} msos_prop_type;
112
113static int usb_desc_msos_prop_name(struct msos_prop *prop,
114 const wchar_t *name)
115{
116 int length = wcslen(name) + 1;
117 int i;
118
119 prop->dwPropertyNameLength_lo = usb_lo(length*2);
120 prop->dwPropertyNameLength_hi = usb_hi(length*2);
121 for (i = 0; i < length; i++) {
122 prop->bPropertyName[i*2] = usb_lo(name[i]);
123 prop->bPropertyName[i*2+1] = usb_hi(name[i]);
124 }
125 return length*2;
126}
127
128static int usb_desc_msos_prop_str(uint8_t *dest, msos_prop_type type,
129 const wchar_t *name, const wchar_t *value)
130{
131 struct msos_prop *prop = (void *)dest;
132 struct msos_prop_data *data;
133 int length = sizeof(*prop);
134 int i, vlen = wcslen(value) + 1;
135
136 prop->dwPropertyDataType = cpu_to_le32(type);
137 length += usb_desc_msos_prop_name(prop, name);
138 data = (void *)(dest + length);
139
140 data->dwPropertyDataLength = cpu_to_le32(vlen*2);
141 length += sizeof(*prop);
142
143 for (i = 0; i < vlen; i++) {
144 data->bPropertyData[i*2] = usb_lo(value[i]);
145 data->bPropertyData[i*2+1] = usb_hi(value[i]);
146 }
147 length += vlen*2;
148
149 prop->dwLength = cpu_to_le32(length);
150 return length;
151}
152
153static int usb_desc_msos_prop_dword(uint8_t *dest, const wchar_t *name,
154 uint32_t value)
155{
156 struct msos_prop *prop = (void *)dest;
157 struct msos_prop_data *data;
158 int length = sizeof(*prop);
159
160 prop->dwPropertyDataType = cpu_to_le32(MSOS_REG_DWORD_LE);
161 length += usb_desc_msos_prop_name(prop, name);
162 data = (void *)(dest + length);
163
164 data->dwPropertyDataLength = cpu_to_le32(4);
165 data->bPropertyData[0] = (value) & 0xff;
166 data->bPropertyData[1] = (value >> 8) & 0xff;
167 data->bPropertyData[2] = (value >> 16) & 0xff;
168 data->bPropertyData[3] = (value >> 24) & 0xff;
169 length += sizeof(*prop) + 4;
170
171 prop->dwLength = cpu_to_le32(length);
172 return length;
173}
174
175static int usb_desc_msos_prop(const USBDesc *desc, uint8_t *dest)
176{
177 msos_prop_hdr *hdr = (void *)dest;
178 int length = sizeof(*hdr);
179 int count = 0;
180
181 if (desc->msos->Label) {
182
183
184
185
186 length += usb_desc_msos_prop_str(dest+length, MSOS_REG_SZ,
187 L"Label", desc->msos->Label);
188 count++;
189 }
190
191 if (desc->msos->SelectiveSuspendEnabled) {
192
193
194
195
196
197
198 length += usb_desc_msos_prop_dword(dest+length,
199 L"SelectiveSuspendEnabled", 1);
200 count++;
201 }
202
203 hdr->dwLength = cpu_to_le32(length);
204 hdr->bcdVersion_lo = 0x00;
205 hdr->bcdVersion_hi = 0x01;
206 hdr->wIndex_lo = 0x05;
207 hdr->wIndex_hi = 0x00;
208 hdr->wCount_lo = usb_lo(count);
209 hdr->wCount_hi = usb_hi(count);
210 return length;
211}
212
213
214
215int usb_desc_msos(const USBDesc *desc, USBPacket *p,
216 int index, uint8_t *dest, size_t len)
217{
218 void *buf = g_malloc0(4096);
219 int length = 0;
220
221 switch (index) {
222 case 0x0004:
223 length = usb_desc_msos_compat(desc, buf);
224 break;
225 case 0x0005:
226 length = usb_desc_msos_prop(desc, buf);
227 break;
228 }
229
230 if (length > len) {
231 length = len;
232 }
233 memcpy(dest, buf, length);
234 g_free(buf);
235
236 p->actual_length = length;
237 return 0;
238}
239