meson: convert qapi-specific to meson
[qemu.git] / hw / usb / desc-msos.c
1 #include "qemu/osdep.h"
2 #include "hw/usb.h"
3 #include "desc.h"
4
5 /*
6 * Microsoft OS Descriptors
7 *
8 * Windows tries to fetch some special descriptors with informations
9 * specifically for windows. Presence is indicated using a special
10 * string @ index 0xee. There are two kinds of descriptors:
11 *
12 * compatid descriptor
13 * Used to bind drivers, if usb class isn't specific enougth.
14 * Used for PTP/MTP for example (both share the same usb class).
15 *
16 * properties descriptor
17 * Does carry registry entries. They show up in
18 * HLM\SYSTEM\CurrentControlSet\Enum\USB\<devid>\<serial>\Device Parameters
19 *
20 * Note that Windows caches the stuff it got in the registry, so when
21 * playing with this you have to delete registry subtrees to make
22 * windows query the device again:
23 * HLM\SYSTEM\CurrentControlSet\Control\usbflags
24 * HLM\SYSTEM\CurrentControlSet\Enum\USB
25 * Windows will complain it can't delete entries on the second one.
26 * It has deleted everything it had permissions too, which is enouth
27 * as this includes "Device Parameters".
28 *
29 * http://msdn.microsoft.com/en-us/library/windows/hardware/ff537430.aspx
30 *
31 */
32
33 /* ------------------------------------------------------------------ */
34
35 typedef struct msos_compat_hdr {
36 uint32_t dwLength;
37 uint8_t bcdVersion_lo;
38 uint8_t bcdVersion_hi;
39 uint8_t wIndex_lo;
40 uint8_t wIndex_hi;
41 uint8_t bCount;
42 uint8_t reserved[7];
43 } QEMU_PACKED msos_compat_hdr;
44
45 typedef struct msos_compat_func {
46 uint8_t bFirstInterfaceNumber;
47 uint8_t reserved_1;
48 char compatibleId[8];
49 uint8_t subCompatibleId[8];
50 uint8_t reserved_2[6];
51 } QEMU_PACKED msos_compat_func;
52
53 static int usb_desc_msos_compat(const USBDesc *desc, uint8_t *dest)
54 {
55 msos_compat_hdr *hdr = (void *)dest;
56 msos_compat_func *func;
57 int length = sizeof(*hdr);
58 int count = 0;
59
60 func = (void *)(dest + length);
61 func->bFirstInterfaceNumber = 0;
62 func->reserved_1 = 0x01;
63 if (desc->msos->CompatibleID) {
64 snprintf(func->compatibleId, sizeof(func->compatibleId),
65 "%s", desc->msos->CompatibleID);
66 }
67 length += sizeof(*func);
68 count++;
69
70 hdr->dwLength = cpu_to_le32(length);
71 hdr->bcdVersion_lo = 0x00;
72 hdr->bcdVersion_hi = 0x01;
73 hdr->wIndex_lo = 0x04;
74 hdr->wIndex_hi = 0x00;
75 hdr->bCount = count;
76 return length;
77 }
78
79 /* ------------------------------------------------------------------ */
80
81 typedef struct msos_prop_hdr {
82 uint32_t dwLength;
83 uint8_t bcdVersion_lo;
84 uint8_t bcdVersion_hi;
85 uint8_t wIndex_lo;
86 uint8_t wIndex_hi;
87 uint8_t wCount_lo;
88 uint8_t wCount_hi;
89 } QEMU_PACKED msos_prop_hdr;
90
91 typedef struct msos_prop {
92 uint32_t dwLength;
93 uint32_t dwPropertyDataType;
94 uint8_t dwPropertyNameLength_lo;
95 uint8_t dwPropertyNameLength_hi;
96 uint8_t bPropertyName[];
97 } QEMU_PACKED msos_prop;
98
99 typedef struct msos_prop_data {
100 uint32_t dwPropertyDataLength;
101 uint8_t bPropertyData[];
102 } QEMU_PACKED msos_prop_data;
103
104 typedef enum msos_prop_type {
105 MSOS_REG_SZ = 1,
106 MSOS_REG_EXPAND_SZ = 2,
107 MSOS_REG_BINARY = 3,
108 MSOS_REG_DWORD_LE = 4,
109 MSOS_REG_DWORD_BE = 5,
110 MSOS_REG_LINK = 6,
111 MSOS_REG_MULTI_SZ = 7,
112 } msos_prop_type;
113
114 static int usb_desc_msos_prop_name(struct msos_prop *prop,
115 const wchar_t *name)
116 {
117 int length = wcslen(name) + 1;
118 int i;
119
120 prop->dwPropertyNameLength_lo = usb_lo(length*2);
121 prop->dwPropertyNameLength_hi = usb_hi(length*2);
122 for (i = 0; i < length; i++) {
123 prop->bPropertyName[i*2] = usb_lo(name[i]);
124 prop->bPropertyName[i*2+1] = usb_hi(name[i]);
125 }
126 return length*2;
127 }
128
129 static int usb_desc_msos_prop_str(uint8_t *dest, msos_prop_type type,
130 const wchar_t *name, const wchar_t *value)
131 {
132 struct msos_prop *prop = (void *)dest;
133 struct msos_prop_data *data;
134 int length = sizeof(*prop);
135 int i, vlen = wcslen(value) + 1;
136
137 prop->dwPropertyDataType = cpu_to_le32(type);
138 length += usb_desc_msos_prop_name(prop, name);
139 data = (void *)(dest + length);
140
141 data->dwPropertyDataLength = cpu_to_le32(vlen*2);
142 length += sizeof(*prop);
143
144 for (i = 0; i < vlen; i++) {
145 data->bPropertyData[i*2] = usb_lo(value[i]);
146 data->bPropertyData[i*2+1] = usb_hi(value[i]);
147 }
148 length += vlen*2;
149
150 prop->dwLength = cpu_to_le32(length);
151 return length;
152 }
153
154 static int usb_desc_msos_prop_dword(uint8_t *dest, const wchar_t *name,
155 uint32_t value)
156 {
157 struct msos_prop *prop = (void *)dest;
158 struct msos_prop_data *data;
159 int length = sizeof(*prop);
160
161 prop->dwPropertyDataType = cpu_to_le32(MSOS_REG_DWORD_LE);
162 length += usb_desc_msos_prop_name(prop, name);
163 data = (void *)(dest + length);
164
165 data->dwPropertyDataLength = cpu_to_le32(4);
166 data->bPropertyData[0] = (value) & 0xff;
167 data->bPropertyData[1] = (value >> 8) & 0xff;
168 data->bPropertyData[2] = (value >> 16) & 0xff;
169 data->bPropertyData[3] = (value >> 24) & 0xff;
170 length += sizeof(*prop) + 4;
171
172 prop->dwLength = cpu_to_le32(length);
173 return length;
174 }
175
176 static int usb_desc_msos_prop(const USBDesc *desc, uint8_t *dest)
177 {
178 msos_prop_hdr *hdr = (void *)dest;
179 int length = sizeof(*hdr);
180 int count = 0;
181
182 if (desc->msos->Label) {
183 /*
184 * Given as example in the specs. Havn't figured yet where
185 * this label shows up in the windows gui.
186 */
187 length += usb_desc_msos_prop_str(dest+length, MSOS_REG_SZ,
188 L"Label", desc->msos->Label);
189 count++;
190 }
191
192 if (desc->msos->SelectiveSuspendEnabled) {
193 /*
194 * Signaling remote wakeup capability in the standard usb
195 * descriptors isn't enouth to make windows actually use it.
196 * This is the "Yes, we really mean it" registy entry to flip
197 * the switch in the windows drivers.
198 */
199 length += usb_desc_msos_prop_dword(dest+length,
200 L"SelectiveSuspendEnabled", 1);
201 count++;
202 }
203
204 hdr->dwLength = cpu_to_le32(length);
205 hdr->bcdVersion_lo = 0x00;
206 hdr->bcdVersion_hi = 0x01;
207 hdr->wIndex_lo = 0x05;
208 hdr->wIndex_hi = 0x00;
209 hdr->wCount_lo = usb_lo(count);
210 hdr->wCount_hi = usb_hi(count);
211 return length;
212 }
213
214 /* ------------------------------------------------------------------ */
215
216 int usb_desc_msos(const USBDesc *desc, USBPacket *p,
217 int index, uint8_t *dest, size_t len)
218 {
219 void *buf = g_malloc0(4096);
220 int length = 0;
221
222 switch (index) {
223 case 0x0004:
224 length = usb_desc_msos_compat(desc, buf);
225 break;
226 case 0x0005:
227 length = usb_desc_msos_prop(desc, buf);
228 break;
229 }
230
231 if (length > len) {
232 length = len;
233 }
234 memcpy(dest, buf, length);
235 g_free(buf);
236
237 p->actual_length = length;
238 return 0;
239 }