]>
Commit | Line | Data |
---|---|---|
6c9f886c AZ |
1 | /* |
2 | * QEMU USB Net devices | |
3 | * | |
4 | * Copyright (c) 2006 Thomas Sailer | |
5 | * Copyright (c) 2008 Andrzej Zaborowski | |
6 | * | |
7 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
8 | * of this software and associated documentation files (the "Software"), to deal | |
9 | * in the Software without restriction, including without limitation the rights | |
10 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
11 | * copies of the Software, and to permit persons to whom the Software is | |
12 | * furnished to do so, subject to the following conditions: | |
13 | * | |
14 | * The above copyright notice and this permission notice shall be included in | |
15 | * all copies or substantial portions of the Software. | |
16 | * | |
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
20 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
21 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
22 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
23 | * THE SOFTWARE. | |
24 | */ | |
25 | ||
e532b2e0 | 26 | #include "qemu/osdep.h" |
da34e65c | 27 | #include "qapi/error.h" |
a27bd6c7 | 28 | #include "hw/qdev-properties.h" |
f1ae32a1 | 29 | #include "hw/usb.h" |
d6454270 | 30 | #include "migration/vmstate.h" |
463581a8 | 31 | #include "desc.h" |
1422e32d | 32 | #include "net/net.h" |
d73ad359 | 33 | #include "qemu/error-report.h" |
1de7afc9 PB |
34 | #include "qemu/queue.h" |
35 | #include "qemu/config-file.h" | |
9c17d615 | 36 | #include "sysemu/sysemu.h" |
1de7afc9 | 37 | #include "qemu/iov.h" |
0b8fa32f | 38 | #include "qemu/module.h" |
f348b6d1 | 39 | #include "qemu/cutils.h" |
db1015e9 | 40 | #include "qom/object.h" |
6c9f886c AZ |
41 | |
42 | /*#define TRAFFIC_DEBUG*/ | |
43 | /* Thanks to NetChip Technologies for donating this product ID. | |
44 | * It's for devices with only CDC Ethernet configurations. | |
45 | */ | |
46 | #define CDC_VENDOR_NUM 0x0525 /* NetChip */ | |
47 | #define CDC_PRODUCT_NUM 0xa4a1 /* Linux-USB Ethernet Gadget */ | |
48 | /* For hardware that can talk RNDIS and either of the above protocols, | |
49 | * use this ID ... the windows INF files will know it. | |
50 | */ | |
51 | #define RNDIS_VENDOR_NUM 0x0525 /* NetChip */ | |
52 | #define RNDIS_PRODUCT_NUM 0xa4a2 /* Ethernet/RNDIS Gadget */ | |
53 | ||
54 | enum usbstring_idx { | |
55 | STRING_MANUFACTURER = 1, | |
56 | STRING_PRODUCT, | |
57 | STRING_ETHADDR, | |
58 | STRING_DATA, | |
59 | STRING_CONTROL, | |
60 | STRING_RNDIS_CONTROL, | |
61 | STRING_CDC, | |
62 | STRING_SUBSET, | |
63 | STRING_RNDIS, | |
64 | STRING_SERIALNUMBER, | |
65 | }; | |
66 | ||
67 | #define DEV_CONFIG_VALUE 1 /* CDC or a subset */ | |
68 | #define DEV_RNDIS_CONFIG_VALUE 2 /* RNDIS; optional */ | |
69 | ||
70 | #define USB_CDC_SUBCLASS_ACM 0x02 | |
71 | #define USB_CDC_SUBCLASS_ETHERNET 0x06 | |
72 | ||
73 | #define USB_CDC_PROTO_NONE 0 | |
74 | #define USB_CDC_ACM_PROTO_VENDOR 0xff | |
75 | ||
76 | #define USB_CDC_HEADER_TYPE 0x00 /* header_desc */ | |
77 | #define USB_CDC_CALL_MANAGEMENT_TYPE 0x01 /* call_mgmt_descriptor */ | |
78 | #define USB_CDC_ACM_TYPE 0x02 /* acm_descriptor */ | |
79 | #define USB_CDC_UNION_TYPE 0x06 /* union_desc */ | |
80 | #define USB_CDC_ETHERNET_TYPE 0x0f /* ether_desc */ | |
81 | ||
6c9f886c AZ |
82 | #define USB_CDC_SEND_ENCAPSULATED_COMMAND 0x00 |
83 | #define USB_CDC_GET_ENCAPSULATED_RESPONSE 0x01 | |
84 | #define USB_CDC_REQ_SET_LINE_CODING 0x20 | |
85 | #define USB_CDC_REQ_GET_LINE_CODING 0x21 | |
86 | #define USB_CDC_REQ_SET_CONTROL_LINE_STATE 0x22 | |
87 | #define USB_CDC_REQ_SEND_BREAK 0x23 | |
88 | #define USB_CDC_SET_ETHERNET_MULTICAST_FILTERS 0x40 | |
89 | #define USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER 0x41 | |
90 | #define USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER 0x42 | |
91 | #define USB_CDC_SET_ETHERNET_PACKET_FILTER 0x43 | |
92 | #define USB_CDC_GET_ETHERNET_STATISTIC 0x44 | |
93 | ||
94 | #define LOG2_STATUS_INTERVAL_MSEC 5 /* 1 << 5 == 32 msec */ | |
95 | #define STATUS_BYTECOUNT 16 /* 8 byte header + data */ | |
96 | ||
97 | #define ETH_FRAME_LEN 1514 /* Max. octets in frame sans FCS */ | |
98 | ||
30c7d32a GH |
99 | static const USBDescStrings usb_net_stringtable = { |
100 | [STRING_MANUFACTURER] = "QEMU", | |
101 | [STRING_PRODUCT] = "RNDIS/QEMU USB Network Device", | |
102 | [STRING_ETHADDR] = "400102030405", | |
103 | [STRING_DATA] = "QEMU USB Net Data Interface", | |
104 | [STRING_CONTROL] = "QEMU USB Net Control Interface", | |
105 | [STRING_RNDIS_CONTROL] = "QEMU USB Net RNDIS Control Interface", | |
106 | [STRING_CDC] = "QEMU USB Net CDC", | |
107 | [STRING_SUBSET] = "QEMU USB Net Subset", | |
108 | [STRING_RNDIS] = "QEMU USB Net RNDIS", | |
109 | [STRING_SERIALNUMBER] = "1", | |
6c9f886c AZ |
110 | }; |
111 | ||
30c7d32a GH |
112 | static const USBDescIface desc_iface_rndis[] = { |
113 | { | |
114 | /* RNDIS Control Interface */ | |
115 | .bInterfaceNumber = 0, | |
116 | .bNumEndpoints = 1, | |
117 | .bInterfaceClass = USB_CLASS_COMM, | |
118 | .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM, | |
119 | .bInterfaceProtocol = USB_CDC_ACM_PROTO_VENDOR, | |
120 | .iInterface = STRING_RNDIS_CONTROL, | |
121 | .ndesc = 4, | |
122 | .descs = (USBDescOther[]) { | |
123 | { | |
124 | /* Header Descriptor */ | |
125 | .data = (uint8_t[]) { | |
126 | 0x05, /* u8 bLength */ | |
127 | USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ | |
128 | USB_CDC_HEADER_TYPE, /* u8 bDescriptorSubType */ | |
129 | 0x10, 0x01, /* le16 bcdCDC */ | |
130 | }, | |
131 | },{ | |
132 | /* Call Management Descriptor */ | |
133 | .data = (uint8_t[]) { | |
134 | 0x05, /* u8 bLength */ | |
135 | USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ | |
136 | USB_CDC_CALL_MANAGEMENT_TYPE, /* u8 bDescriptorSubType */ | |
137 | 0x00, /* u8 bmCapabilities */ | |
138 | 0x01, /* u8 bDataInterface */ | |
139 | }, | |
140 | },{ | |
141 | /* ACM Descriptor */ | |
142 | .data = (uint8_t[]) { | |
143 | 0x04, /* u8 bLength */ | |
144 | USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ | |
145 | USB_CDC_ACM_TYPE, /* u8 bDescriptorSubType */ | |
146 | 0x00, /* u8 bmCapabilities */ | |
147 | }, | |
148 | },{ | |
149 | /* Union Descriptor */ | |
150 | .data = (uint8_t[]) { | |
151 | 0x05, /* u8 bLength */ | |
152 | USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ | |
153 | USB_CDC_UNION_TYPE, /* u8 bDescriptorSubType */ | |
154 | 0x00, /* u8 bMasterInterface0 */ | |
155 | 0x01, /* u8 bSlaveInterface0 */ | |
156 | }, | |
157 | }, | |
158 | }, | |
159 | .eps = (USBDescEndpoint[]) { | |
160 | { | |
161 | .bEndpointAddress = USB_DIR_IN | 0x01, | |
162 | .bmAttributes = USB_ENDPOINT_XFER_INT, | |
163 | .wMaxPacketSize = STATUS_BYTECOUNT, | |
164 | .bInterval = 1 << LOG2_STATUS_INTERVAL_MSEC, | |
165 | }, | |
166 | } | |
167 | },{ | |
168 | /* RNDIS Data Interface */ | |
169 | .bInterfaceNumber = 1, | |
170 | .bNumEndpoints = 2, | |
171 | .bInterfaceClass = USB_CLASS_CDC_DATA, | |
172 | .iInterface = STRING_DATA, | |
173 | .eps = (USBDescEndpoint[]) { | |
174 | { | |
175 | .bEndpointAddress = USB_DIR_IN | 0x02, | |
176 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | |
177 | .wMaxPacketSize = 0x40, | |
178 | },{ | |
179 | .bEndpointAddress = USB_DIR_OUT | 0x02, | |
180 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | |
181 | .wMaxPacketSize = 0x40, | |
182 | } | |
183 | } | |
184 | } | |
6c9f886c AZ |
185 | }; |
186 | ||
30c7d32a GH |
187 | static const USBDescIface desc_iface_cdc[] = { |
188 | { | |
189 | /* CDC Control Interface */ | |
190 | .bInterfaceNumber = 0, | |
191 | .bNumEndpoints = 1, | |
192 | .bInterfaceClass = USB_CLASS_COMM, | |
193 | .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET, | |
194 | .bInterfaceProtocol = USB_CDC_PROTO_NONE, | |
195 | .iInterface = STRING_CONTROL, | |
196 | .ndesc = 3, | |
197 | .descs = (USBDescOther[]) { | |
198 | { | |
199 | /* Header Descriptor */ | |
200 | .data = (uint8_t[]) { | |
201 | 0x05, /* u8 bLength */ | |
202 | USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ | |
203 | USB_CDC_HEADER_TYPE, /* u8 bDescriptorSubType */ | |
204 | 0x10, 0x01, /* le16 bcdCDC */ | |
205 | }, | |
206 | },{ | |
207 | /* Union Descriptor */ | |
208 | .data = (uint8_t[]) { | |
209 | 0x05, /* u8 bLength */ | |
210 | USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ | |
211 | USB_CDC_UNION_TYPE, /* u8 bDescriptorSubType */ | |
212 | 0x00, /* u8 bMasterInterface0 */ | |
213 | 0x01, /* u8 bSlaveInterface0 */ | |
214 | }, | |
215 | },{ | |
216 | /* Ethernet Descriptor */ | |
217 | .data = (uint8_t[]) { | |
218 | 0x0d, /* u8 bLength */ | |
219 | USB_DT_CS_INTERFACE, /* u8 bDescriptorType */ | |
220 | USB_CDC_ETHERNET_TYPE, /* u8 bDescriptorSubType */ | |
221 | STRING_ETHADDR, /* u8 iMACAddress */ | |
222 | 0x00, 0x00, 0x00, 0x00, /* le32 bmEthernetStatistics */ | |
223 | ETH_FRAME_LEN & 0xff, | |
224 | ETH_FRAME_LEN >> 8, /* le16 wMaxSegmentSize */ | |
225 | 0x00, 0x00, /* le16 wNumberMCFilters */ | |
226 | 0x00, /* u8 bNumberPowerFilters */ | |
227 | }, | |
228 | }, | |
229 | }, | |
230 | .eps = (USBDescEndpoint[]) { | |
231 | { | |
232 | .bEndpointAddress = USB_DIR_IN | 0x01, | |
233 | .bmAttributes = USB_ENDPOINT_XFER_INT, | |
234 | .wMaxPacketSize = STATUS_BYTECOUNT, | |
235 | .bInterval = 1 << LOG2_STATUS_INTERVAL_MSEC, | |
236 | }, | |
237 | } | |
238 | },{ | |
239 | /* CDC Data Interface (off) */ | |
240 | .bInterfaceNumber = 1, | |
241 | .bAlternateSetting = 0, | |
242 | .bNumEndpoints = 0, | |
243 | .bInterfaceClass = USB_CLASS_CDC_DATA, | |
244 | },{ | |
245 | /* CDC Data Interface */ | |
246 | .bInterfaceNumber = 1, | |
247 | .bAlternateSetting = 1, | |
248 | .bNumEndpoints = 2, | |
249 | .bInterfaceClass = USB_CLASS_CDC_DATA, | |
250 | .iInterface = STRING_DATA, | |
251 | .eps = (USBDescEndpoint[]) { | |
252 | { | |
253 | .bEndpointAddress = USB_DIR_IN | 0x02, | |
254 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | |
255 | .wMaxPacketSize = 0x40, | |
256 | },{ | |
257 | .bEndpointAddress = USB_DIR_OUT | 0x02, | |
258 | .bmAttributes = USB_ENDPOINT_XFER_BULK, | |
259 | .wMaxPacketSize = 0x40, | |
260 | } | |
261 | } | |
262 | } | |
263 | }; | |
264 | ||
265 | static const USBDescDevice desc_device_net = { | |
266 | .bcdUSB = 0x0200, | |
267 | .bDeviceClass = USB_CLASS_COMM, | |
268 | .bMaxPacketSize0 = 0x40, | |
269 | .bNumConfigurations = 2, | |
270 | .confs = (USBDescConfig[]) { | |
271 | { | |
272 | .bNumInterfaces = 2, | |
273 | .bConfigurationValue = DEV_RNDIS_CONFIG_VALUE, | |
274 | .iConfiguration = STRING_RNDIS, | |
bd93976a | 275 | .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER, |
30c7d32a GH |
276 | .bMaxPower = 0x32, |
277 | .nif = ARRAY_SIZE(desc_iface_rndis), | |
278 | .ifs = desc_iface_rndis, | |
279 | },{ | |
280 | .bNumInterfaces = 2, | |
281 | .bConfigurationValue = DEV_CONFIG_VALUE, | |
282 | .iConfiguration = STRING_CDC, | |
bd93976a | 283 | .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER, |
30c7d32a GH |
284 | .bMaxPower = 0x32, |
285 | .nif = ARRAY_SIZE(desc_iface_cdc), | |
286 | .ifs = desc_iface_cdc, | |
287 | } | |
288 | }, | |
289 | }; | |
290 | ||
291 | static const USBDesc desc_net = { | |
292 | .id = { | |
293 | .idVendor = RNDIS_VENDOR_NUM, | |
294 | .idProduct = RNDIS_PRODUCT_NUM, | |
295 | .bcdDevice = 0, | |
296 | .iManufacturer = STRING_MANUFACTURER, | |
297 | .iProduct = STRING_PRODUCT, | |
298 | .iSerialNumber = STRING_SERIALNUMBER, | |
299 | }, | |
300 | .full = &desc_device_net, | |
301 | .str = usb_net_stringtable, | |
6c9f886c AZ |
302 | }; |
303 | ||
304 | /* | |
305 | * RNDIS Definitions - in theory not specific to USB. | |
306 | */ | |
307 | #define RNDIS_MAXIMUM_FRAME_SIZE 1518 | |
308 | #define RNDIS_MAX_TOTAL_SIZE 1558 | |
309 | ||
310 | /* Remote NDIS Versions */ | |
311 | #define RNDIS_MAJOR_VERSION 1 | |
312 | #define RNDIS_MINOR_VERSION 0 | |
313 | ||
314 | /* Status Values */ | |
315 | #define RNDIS_STATUS_SUCCESS 0x00000000U /* Success */ | |
316 | #define RNDIS_STATUS_FAILURE 0xc0000001U /* Unspecified error */ | |
317 | #define RNDIS_STATUS_INVALID_DATA 0xc0010015U /* Invalid data */ | |
318 | #define RNDIS_STATUS_NOT_SUPPORTED 0xc00000bbU /* Unsupported request */ | |
319 | #define RNDIS_STATUS_MEDIA_CONNECT 0x4001000bU /* Device connected */ | |
320 | #define RNDIS_STATUS_MEDIA_DISCONNECT 0x4001000cU /* Device disconnected */ | |
321 | ||
322 | /* Message Set for Connectionless (802.3) Devices */ | |
323 | enum { | |
324 | RNDIS_PACKET_MSG = 1, | |
325 | RNDIS_INITIALIZE_MSG = 2, /* Initialize device */ | |
326 | RNDIS_HALT_MSG = 3, | |
327 | RNDIS_QUERY_MSG = 4, | |
328 | RNDIS_SET_MSG = 5, | |
329 | RNDIS_RESET_MSG = 6, | |
330 | RNDIS_INDICATE_STATUS_MSG = 7, | |
331 | RNDIS_KEEPALIVE_MSG = 8, | |
332 | }; | |
333 | ||
334 | /* Message completion */ | |
335 | enum { | |
336 | RNDIS_INITIALIZE_CMPLT = 0x80000002U, | |
337 | RNDIS_QUERY_CMPLT = 0x80000004U, | |
338 | RNDIS_SET_CMPLT = 0x80000005U, | |
339 | RNDIS_RESET_CMPLT = 0x80000006U, | |
340 | RNDIS_KEEPALIVE_CMPLT = 0x80000008U, | |
341 | }; | |
342 | ||
343 | /* Device Flags */ | |
344 | enum { | |
345 | RNDIS_DF_CONNECTIONLESS = 1, | |
346 | RNDIS_DF_CONNECTIONORIENTED = 2, | |
347 | }; | |
348 | ||
349 | #define RNDIS_MEDIUM_802_3 0x00000000U | |
350 | ||
351 | /* from drivers/net/sk98lin/h/skgepnmi.h */ | |
352 | #define OID_PNP_CAPABILITIES 0xfd010100 | |
353 | #define OID_PNP_SET_POWER 0xfd010101 | |
354 | #define OID_PNP_QUERY_POWER 0xfd010102 | |
355 | #define OID_PNP_ADD_WAKE_UP_PATTERN 0xfd010103 | |
356 | #define OID_PNP_REMOVE_WAKE_UP_PATTERN 0xfd010104 | |
357 | #define OID_PNP_ENABLE_WAKE_UP 0xfd010106 | |
358 | ||
359 | typedef uint32_t le32; | |
360 | ||
361 | typedef struct rndis_init_msg_type { | |
362 | le32 MessageType; | |
363 | le32 MessageLength; | |
364 | le32 RequestID; | |
365 | le32 MajorVersion; | |
366 | le32 MinorVersion; | |
367 | le32 MaxTransferSize; | |
368 | } rndis_init_msg_type; | |
369 | ||
370 | typedef struct rndis_init_cmplt_type { | |
371 | le32 MessageType; | |
372 | le32 MessageLength; | |
373 | le32 RequestID; | |
374 | le32 Status; | |
375 | le32 MajorVersion; | |
376 | le32 MinorVersion; | |
377 | le32 DeviceFlags; | |
378 | le32 Medium; | |
379 | le32 MaxPacketsPerTransfer; | |
380 | le32 MaxTransferSize; | |
381 | le32 PacketAlignmentFactor; | |
382 | le32 AFListOffset; | |
383 | le32 AFListSize; | |
384 | } rndis_init_cmplt_type; | |
385 | ||
386 | typedef struct rndis_halt_msg_type { | |
387 | le32 MessageType; | |
388 | le32 MessageLength; | |
389 | le32 RequestID; | |
390 | } rndis_halt_msg_type; | |
391 | ||
392 | typedef struct rndis_query_msg_type { | |
393 | le32 MessageType; | |
394 | le32 MessageLength; | |
395 | le32 RequestID; | |
396 | le32 OID; | |
397 | le32 InformationBufferLength; | |
398 | le32 InformationBufferOffset; | |
399 | le32 DeviceVcHandle; | |
400 | } rndis_query_msg_type; | |
401 | ||
402 | typedef struct rndis_query_cmplt_type { | |
403 | le32 MessageType; | |
404 | le32 MessageLength; | |
405 | le32 RequestID; | |
406 | le32 Status; | |
407 | le32 InformationBufferLength; | |
408 | le32 InformationBufferOffset; | |
409 | } rndis_query_cmplt_type; | |
410 | ||
411 | typedef struct rndis_set_msg_type { | |
412 | le32 MessageType; | |
413 | le32 MessageLength; | |
414 | le32 RequestID; | |
415 | le32 OID; | |
416 | le32 InformationBufferLength; | |
417 | le32 InformationBufferOffset; | |
418 | le32 DeviceVcHandle; | |
419 | } rndis_set_msg_type; | |
420 | ||
421 | typedef struct rndis_set_cmplt_type { | |
422 | le32 MessageType; | |
423 | le32 MessageLength; | |
424 | le32 RequestID; | |
425 | le32 Status; | |
426 | } rndis_set_cmplt_type; | |
427 | ||
428 | typedef struct rndis_reset_msg_type { | |
429 | le32 MessageType; | |
430 | le32 MessageLength; | |
431 | le32 Reserved; | |
432 | } rndis_reset_msg_type; | |
433 | ||
434 | typedef struct rndis_reset_cmplt_type { | |
435 | le32 MessageType; | |
436 | le32 MessageLength; | |
437 | le32 Status; | |
438 | le32 AddressingReset; | |
439 | } rndis_reset_cmplt_type; | |
440 | ||
441 | typedef struct rndis_indicate_status_msg_type { | |
442 | le32 MessageType; | |
443 | le32 MessageLength; | |
444 | le32 Status; | |
445 | le32 StatusBufferLength; | |
446 | le32 StatusBufferOffset; | |
447 | } rndis_indicate_status_msg_type; | |
448 | ||
449 | typedef struct rndis_keepalive_msg_type { | |
450 | le32 MessageType; | |
451 | le32 MessageLength; | |
452 | le32 RequestID; | |
453 | } rndis_keepalive_msg_type; | |
454 | ||
455 | typedef struct rndis_keepalive_cmplt_type { | |
456 | le32 MessageType; | |
457 | le32 MessageLength; | |
458 | le32 RequestID; | |
459 | le32 Status; | |
460 | } rndis_keepalive_cmplt_type; | |
461 | ||
462 | struct rndis_packet_msg_type { | |
463 | le32 MessageType; | |
464 | le32 MessageLength; | |
465 | le32 DataOffset; | |
466 | le32 DataLength; | |
467 | le32 OOBDataOffset; | |
468 | le32 OOBDataLength; | |
469 | le32 NumOOBDataElements; | |
470 | le32 PerPacketInfoOffset; | |
471 | le32 PerPacketInfoLength; | |
472 | le32 VcHandle; | |
473 | le32 Reserved; | |
474 | }; | |
475 | ||
476 | struct rndis_config_parameter { | |
477 | le32 ParameterNameOffset; | |
478 | le32 ParameterNameLength; | |
479 | le32 ParameterType; | |
480 | le32 ParameterValueOffset; | |
481 | le32 ParameterValueLength; | |
482 | }; | |
483 | ||
484 | /* implementation specific */ | |
485 | enum rndis_state | |
486 | { | |
487 | RNDIS_UNINITIALIZED, | |
488 | RNDIS_INITIALIZED, | |
489 | RNDIS_DATA_INITIALIZED, | |
490 | }; | |
491 | ||
492 | /* from ndis.h */ | |
493 | enum ndis_oid { | |
494 | /* Required Object IDs (OIDs) */ | |
495 | OID_GEN_SUPPORTED_LIST = 0x00010101, | |
496 | OID_GEN_HARDWARE_STATUS = 0x00010102, | |
497 | OID_GEN_MEDIA_SUPPORTED = 0x00010103, | |
498 | OID_GEN_MEDIA_IN_USE = 0x00010104, | |
499 | OID_GEN_MAXIMUM_LOOKAHEAD = 0x00010105, | |
500 | OID_GEN_MAXIMUM_FRAME_SIZE = 0x00010106, | |
501 | OID_GEN_LINK_SPEED = 0x00010107, | |
502 | OID_GEN_TRANSMIT_BUFFER_SPACE = 0x00010108, | |
503 | OID_GEN_RECEIVE_BUFFER_SPACE = 0x00010109, | |
504 | OID_GEN_TRANSMIT_BLOCK_SIZE = 0x0001010a, | |
505 | OID_GEN_RECEIVE_BLOCK_SIZE = 0x0001010b, | |
506 | OID_GEN_VENDOR_ID = 0x0001010c, | |
507 | OID_GEN_VENDOR_DESCRIPTION = 0x0001010d, | |
508 | OID_GEN_CURRENT_PACKET_FILTER = 0x0001010e, | |
509 | OID_GEN_CURRENT_LOOKAHEAD = 0x0001010f, | |
510 | OID_GEN_DRIVER_VERSION = 0x00010110, | |
511 | OID_GEN_MAXIMUM_TOTAL_SIZE = 0x00010111, | |
512 | OID_GEN_PROTOCOL_OPTIONS = 0x00010112, | |
513 | OID_GEN_MAC_OPTIONS = 0x00010113, | |
514 | OID_GEN_MEDIA_CONNECT_STATUS = 0x00010114, | |
515 | OID_GEN_MAXIMUM_SEND_PACKETS = 0x00010115, | |
516 | OID_GEN_VENDOR_DRIVER_VERSION = 0x00010116, | |
517 | OID_GEN_SUPPORTED_GUIDS = 0x00010117, | |
518 | OID_GEN_NETWORK_LAYER_ADDRESSES = 0x00010118, | |
519 | OID_GEN_TRANSPORT_HEADER_OFFSET = 0x00010119, | |
520 | OID_GEN_MACHINE_NAME = 0x0001021a, | |
521 | OID_GEN_RNDIS_CONFIG_PARAMETER = 0x0001021b, | |
522 | OID_GEN_VLAN_ID = 0x0001021c, | |
523 | ||
524 | /* Optional OIDs */ | |
525 | OID_GEN_MEDIA_CAPABILITIES = 0x00010201, | |
526 | OID_GEN_PHYSICAL_MEDIUM = 0x00010202, | |
527 | ||
528 | /* Required statistics OIDs */ | |
529 | OID_GEN_XMIT_OK = 0x00020101, | |
530 | OID_GEN_RCV_OK = 0x00020102, | |
531 | OID_GEN_XMIT_ERROR = 0x00020103, | |
532 | OID_GEN_RCV_ERROR = 0x00020104, | |
533 | OID_GEN_RCV_NO_BUFFER = 0x00020105, | |
534 | ||
535 | /* Optional statistics OIDs */ | |
536 | OID_GEN_DIRECTED_BYTES_XMIT = 0x00020201, | |
537 | OID_GEN_DIRECTED_FRAMES_XMIT = 0x00020202, | |
538 | OID_GEN_MULTICAST_BYTES_XMIT = 0x00020203, | |
539 | OID_GEN_MULTICAST_FRAMES_XMIT = 0x00020204, | |
540 | OID_GEN_BROADCAST_BYTES_XMIT = 0x00020205, | |
541 | OID_GEN_BROADCAST_FRAMES_XMIT = 0x00020206, | |
542 | OID_GEN_DIRECTED_BYTES_RCV = 0x00020207, | |
543 | OID_GEN_DIRECTED_FRAMES_RCV = 0x00020208, | |
544 | OID_GEN_MULTICAST_BYTES_RCV = 0x00020209, | |
545 | OID_GEN_MULTICAST_FRAMES_RCV = 0x0002020a, | |
546 | OID_GEN_BROADCAST_BYTES_RCV = 0x0002020b, | |
547 | OID_GEN_BROADCAST_FRAMES_RCV = 0x0002020c, | |
548 | OID_GEN_RCV_CRC_ERROR = 0x0002020d, | |
549 | OID_GEN_TRANSMIT_QUEUE_LENGTH = 0x0002020e, | |
550 | OID_GEN_GET_TIME_CAPS = 0x0002020f, | |
551 | OID_GEN_GET_NETCARD_TIME = 0x00020210, | |
552 | OID_GEN_NETCARD_LOAD = 0x00020211, | |
553 | OID_GEN_DEVICE_PROFILE = 0x00020212, | |
554 | OID_GEN_INIT_TIME_MS = 0x00020213, | |
555 | OID_GEN_RESET_COUNTS = 0x00020214, | |
556 | OID_GEN_MEDIA_SENSE_COUNTS = 0x00020215, | |
557 | OID_GEN_FRIENDLY_NAME = 0x00020216, | |
558 | OID_GEN_MINIPORT_INFO = 0x00020217, | |
559 | OID_GEN_RESET_VERIFY_PARAMETERS = 0x00020218, | |
560 | ||
561 | /* IEEE 802.3 (Ethernet) OIDs */ | |
562 | OID_802_3_PERMANENT_ADDRESS = 0x01010101, | |
563 | OID_802_3_CURRENT_ADDRESS = 0x01010102, | |
564 | OID_802_3_MULTICAST_LIST = 0x01010103, | |
565 | OID_802_3_MAXIMUM_LIST_SIZE = 0x01010104, | |
566 | OID_802_3_MAC_OPTIONS = 0x01010105, | |
567 | OID_802_3_RCV_ERROR_ALIGNMENT = 0x01020101, | |
568 | OID_802_3_XMIT_ONE_COLLISION = 0x01020102, | |
569 | OID_802_3_XMIT_MORE_COLLISIONS = 0x01020103, | |
570 | OID_802_3_XMIT_DEFERRED = 0x01020201, | |
571 | OID_802_3_XMIT_MAX_COLLISIONS = 0x01020202, | |
572 | OID_802_3_RCV_OVERRUN = 0x01020203, | |
573 | OID_802_3_XMIT_UNDERRUN = 0x01020204, | |
574 | OID_802_3_XMIT_HEARTBEAT_FAILURE = 0x01020205, | |
575 | OID_802_3_XMIT_TIMES_CRS_LOST = 0x01020206, | |
576 | OID_802_3_XMIT_LATE_COLLISIONS = 0x01020207, | |
577 | }; | |
578 | ||
579 | static const uint32_t oid_supported_list[] = | |
580 | { | |
581 | /* the general stuff */ | |
582 | OID_GEN_SUPPORTED_LIST, | |
583 | OID_GEN_HARDWARE_STATUS, | |
584 | OID_GEN_MEDIA_SUPPORTED, | |
585 | OID_GEN_MEDIA_IN_USE, | |
586 | OID_GEN_MAXIMUM_FRAME_SIZE, | |
587 | OID_GEN_LINK_SPEED, | |
588 | OID_GEN_TRANSMIT_BLOCK_SIZE, | |
589 | OID_GEN_RECEIVE_BLOCK_SIZE, | |
590 | OID_GEN_VENDOR_ID, | |
591 | OID_GEN_VENDOR_DESCRIPTION, | |
592 | OID_GEN_VENDOR_DRIVER_VERSION, | |
593 | OID_GEN_CURRENT_PACKET_FILTER, | |
594 | OID_GEN_MAXIMUM_TOTAL_SIZE, | |
595 | OID_GEN_MEDIA_CONNECT_STATUS, | |
596 | OID_GEN_PHYSICAL_MEDIUM, | |
597 | ||
598 | /* the statistical stuff */ | |
599 | OID_GEN_XMIT_OK, | |
600 | OID_GEN_RCV_OK, | |
601 | OID_GEN_XMIT_ERROR, | |
602 | OID_GEN_RCV_ERROR, | |
603 | OID_GEN_RCV_NO_BUFFER, | |
604 | ||
605 | /* IEEE 802.3 */ | |
606 | /* the general stuff */ | |
607 | OID_802_3_PERMANENT_ADDRESS, | |
608 | OID_802_3_CURRENT_ADDRESS, | |
609 | OID_802_3_MULTICAST_LIST, | |
610 | OID_802_3_MAC_OPTIONS, | |
611 | OID_802_3_MAXIMUM_LIST_SIZE, | |
612 | ||
613 | /* the statistical stuff */ | |
614 | OID_802_3_RCV_ERROR_ALIGNMENT, | |
615 | OID_802_3_XMIT_ONE_COLLISION, | |
616 | OID_802_3_XMIT_MORE_COLLISIONS, | |
617 | }; | |
618 | ||
619 | #define NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA (1 << 0) | |
620 | #define NDIS_MAC_OPTION_RECEIVE_SERIALIZED (1 << 1) | |
621 | #define NDIS_MAC_OPTION_TRANSFERS_NOT_PEND (1 << 2) | |
622 | #define NDIS_MAC_OPTION_NO_LOOPBACK (1 << 3) | |
623 | #define NDIS_MAC_OPTION_FULL_DUPLEX (1 << 4) | |
624 | #define NDIS_MAC_OPTION_EOTX_INDICATION (1 << 5) | |
625 | #define NDIS_MAC_OPTION_8021P_PRIORITY (1 << 6) | |
626 | ||
627 | struct rndis_response { | |
72cf2d4f | 628 | QTAILQ_ENTRY(rndis_response) entries; |
6c9f886c | 629 | uint32_t length; |
f7795e40 | 630 | uint8_t buf[]; |
6c9f886c AZ |
631 | }; |
632 | ||
db1015e9 | 633 | struct USBNetState { |
6c9f886c AZ |
634 | USBDevice dev; |
635 | ||
6c9f886c AZ |
636 | enum rndis_state rndis_state; |
637 | uint32_t medium; | |
638 | uint32_t speed; | |
639 | uint32_t media_state; | |
640 | uint16_t filter; | |
641 | uint32_t vendorid; | |
6c9f886c AZ |
642 | |
643 | unsigned int out_ptr; | |
644 | uint8_t out_buf[2048]; | |
645 | ||
6c9f886c AZ |
646 | unsigned int in_ptr, in_len; |
647 | uint8_t in_buf[2048]; | |
648 | ||
8beba930 HG |
649 | USBEndpoint *intr; |
650 | ||
6c9f886c | 651 | char usbstring_mac[13]; |
e0394b8b MM |
652 | NICState *nic; |
653 | NICConf conf; | |
b58deb34 | 654 | QTAILQ_HEAD(, rndis_response) rndis_resp; |
db1015e9 EH |
655 | }; |
656 | typedef struct USBNetState USBNetState; | |
6c9f886c | 657 | |
fe47db72 | 658 | #define TYPE_USB_NET "usb-net" |
8110fa1d EH |
659 | DECLARE_INSTANCE_CHECKER(USBNetState, USB_NET, |
660 | TYPE_USB_NET) | |
fe47db72 | 661 | |
a980a065 GH |
662 | static int is_rndis(USBNetState *s) |
663 | { | |
80eecda8 PP |
664 | return s->dev.config ? |
665 | s->dev.config->bConfigurationValue == DEV_RNDIS_CONFIG_VALUE : 0; | |
a980a065 GH |
666 | } |
667 | ||
6c9f886c | 668 | static int ndis_query(USBNetState *s, uint32_t oid, |
363a37d5 BS |
669 | uint8_t *inbuf, unsigned int inlen, uint8_t *outbuf, |
670 | size_t outlen) | |
6c9f886c | 671 | { |
b1503cda | 672 | unsigned int i; |
6c9f886c AZ |
673 | |
674 | switch (oid) { | |
675 | /* general oids (table 4-1) */ | |
676 | /* mandatory */ | |
677 | case OID_GEN_SUPPORTED_LIST: | |
ec9125bc PM |
678 | for (i = 0; i < ARRAY_SIZE(oid_supported_list); i++) { |
679 | stl_le_p(outbuf + (i * sizeof(le32)), oid_supported_list[i]); | |
680 | } | |
6c9f886c AZ |
681 | return sizeof(oid_supported_list); |
682 | ||
683 | /* mandatory */ | |
684 | case OID_GEN_HARDWARE_STATUS: | |
ec9125bc | 685 | stl_le_p(outbuf, 0); |
6c9f886c AZ |
686 | return sizeof(le32); |
687 | ||
688 | /* mandatory */ | |
689 | case OID_GEN_MEDIA_SUPPORTED: | |
ec9125bc | 690 | stl_le_p(outbuf, s->medium); |
6c9f886c AZ |
691 | return sizeof(le32); |
692 | ||
693 | /* mandatory */ | |
694 | case OID_GEN_MEDIA_IN_USE: | |
ec9125bc | 695 | stl_le_p(outbuf, s->medium); |
6c9f886c AZ |
696 | return sizeof(le32); |
697 | ||
698 | /* mandatory */ | |
699 | case OID_GEN_MAXIMUM_FRAME_SIZE: | |
ec9125bc | 700 | stl_le_p(outbuf, ETH_FRAME_LEN); |
6c9f886c AZ |
701 | return sizeof(le32); |
702 | ||
703 | /* mandatory */ | |
704 | case OID_GEN_LINK_SPEED: | |
ec9125bc | 705 | stl_le_p(outbuf, s->speed); |
6c9f886c AZ |
706 | return sizeof(le32); |
707 | ||
708 | /* mandatory */ | |
709 | case OID_GEN_TRANSMIT_BLOCK_SIZE: | |
ec9125bc | 710 | stl_le_p(outbuf, ETH_FRAME_LEN); |
6c9f886c AZ |
711 | return sizeof(le32); |
712 | ||
713 | /* mandatory */ | |
714 | case OID_GEN_RECEIVE_BLOCK_SIZE: | |
ec9125bc | 715 | stl_le_p(outbuf, ETH_FRAME_LEN); |
6c9f886c AZ |
716 | return sizeof(le32); |
717 | ||
718 | /* mandatory */ | |
719 | case OID_GEN_VENDOR_ID: | |
ec9125bc | 720 | stl_le_p(outbuf, s->vendorid); |
6c9f886c AZ |
721 | return sizeof(le32); |
722 | ||
723 | /* mandatory */ | |
724 | case OID_GEN_VENDOR_DESCRIPTION: | |
b55266b5 BS |
725 | pstrcpy((char *)outbuf, outlen, "QEMU USB RNDIS Net"); |
726 | return strlen((char *)outbuf) + 1; | |
6c9f886c AZ |
727 | |
728 | case OID_GEN_VENDOR_DRIVER_VERSION: | |
ec9125bc | 729 | stl_le_p(outbuf, 1); |
6c9f886c AZ |
730 | return sizeof(le32); |
731 | ||
732 | /* mandatory */ | |
733 | case OID_GEN_CURRENT_PACKET_FILTER: | |
ec9125bc | 734 | stl_le_p(outbuf, s->filter); |
6c9f886c AZ |
735 | return sizeof(le32); |
736 | ||
737 | /* mandatory */ | |
738 | case OID_GEN_MAXIMUM_TOTAL_SIZE: | |
ec9125bc | 739 | stl_le_p(outbuf, RNDIS_MAX_TOTAL_SIZE); |
6c9f886c AZ |
740 | return sizeof(le32); |
741 | ||
742 | /* mandatory */ | |
743 | case OID_GEN_MEDIA_CONNECT_STATUS: | |
ec9125bc | 744 | stl_le_p(outbuf, s->media_state); |
6c9f886c AZ |
745 | return sizeof(le32); |
746 | ||
747 | case OID_GEN_PHYSICAL_MEDIUM: | |
ec9125bc | 748 | stl_le_p(outbuf, 0); |
6c9f886c AZ |
749 | return sizeof(le32); |
750 | ||
751 | case OID_GEN_MAC_OPTIONS: | |
ec9125bc PM |
752 | stl_le_p(outbuf, NDIS_MAC_OPTION_RECEIVE_SERIALIZED | |
753 | NDIS_MAC_OPTION_FULL_DUPLEX); | |
6c9f886c AZ |
754 | return sizeof(le32); |
755 | ||
756 | /* statistics OIDs (table 4-2) */ | |
757 | /* mandatory */ | |
758 | case OID_GEN_XMIT_OK: | |
ec9125bc | 759 | stl_le_p(outbuf, 0); |
6c9f886c AZ |
760 | return sizeof(le32); |
761 | ||
762 | /* mandatory */ | |
763 | case OID_GEN_RCV_OK: | |
ec9125bc | 764 | stl_le_p(outbuf, 0); |
6c9f886c AZ |
765 | return sizeof(le32); |
766 | ||
767 | /* mandatory */ | |
768 | case OID_GEN_XMIT_ERROR: | |
ec9125bc | 769 | stl_le_p(outbuf, 0); |
6c9f886c AZ |
770 | return sizeof(le32); |
771 | ||
772 | /* mandatory */ | |
773 | case OID_GEN_RCV_ERROR: | |
ec9125bc | 774 | stl_le_p(outbuf, 0); |
6c9f886c AZ |
775 | return sizeof(le32); |
776 | ||
777 | /* mandatory */ | |
778 | case OID_GEN_RCV_NO_BUFFER: | |
ec9125bc | 779 | stl_le_p(outbuf, 0); |
6c9f886c AZ |
780 | return sizeof(le32); |
781 | ||
782 | /* ieee802.3 OIDs (table 4-3) */ | |
783 | /* mandatory */ | |
784 | case OID_802_3_PERMANENT_ADDRESS: | |
e0394b8b | 785 | memcpy(outbuf, s->conf.macaddr.a, 6); |
6c9f886c AZ |
786 | return 6; |
787 | ||
788 | /* mandatory */ | |
789 | case OID_802_3_CURRENT_ADDRESS: | |
e0394b8b | 790 | memcpy(outbuf, s->conf.macaddr.a, 6); |
6c9f886c AZ |
791 | return 6; |
792 | ||
793 | /* mandatory */ | |
794 | case OID_802_3_MULTICAST_LIST: | |
ec9125bc | 795 | stl_le_p(outbuf, 0xe0000000); |
6c9f886c AZ |
796 | return sizeof(le32); |
797 | ||
798 | /* mandatory */ | |
799 | case OID_802_3_MAXIMUM_LIST_SIZE: | |
ec9125bc | 800 | stl_le_p(outbuf, 1); |
6c9f886c AZ |
801 | return sizeof(le32); |
802 | ||
803 | case OID_802_3_MAC_OPTIONS: | |
804 | return 0; | |
805 | ||
806 | /* ieee802.3 statistics OIDs (table 4-4) */ | |
807 | /* mandatory */ | |
808 | case OID_802_3_RCV_ERROR_ALIGNMENT: | |
ec9125bc | 809 | stl_le_p(outbuf, 0); |
6c9f886c AZ |
810 | return sizeof(le32); |
811 | ||
812 | /* mandatory */ | |
813 | case OID_802_3_XMIT_ONE_COLLISION: | |
ec9125bc | 814 | stl_le_p(outbuf, 0); |
6c9f886c AZ |
815 | return sizeof(le32); |
816 | ||
817 | /* mandatory */ | |
818 | case OID_802_3_XMIT_MORE_COLLISIONS: | |
ec9125bc | 819 | stl_le_p(outbuf, 0); |
6c9f886c AZ |
820 | return sizeof(le32); |
821 | ||
822 | default: | |
823 | fprintf(stderr, "usbnet: unknown OID 0x%08x\n", oid); | |
824 | return 0; | |
825 | } | |
826 | return -1; | |
827 | } | |
828 | ||
829 | static int ndis_set(USBNetState *s, uint32_t oid, | |
830 | uint8_t *inbuf, unsigned int inlen) | |
831 | { | |
832 | switch (oid) { | |
833 | case OID_GEN_CURRENT_PACKET_FILTER: | |
ec9125bc | 834 | s->filter = ldl_le_p(inbuf); |
6c9f886c AZ |
835 | if (s->filter) { |
836 | s->rndis_state = RNDIS_DATA_INITIALIZED; | |
837 | } else { | |
838 | s->rndis_state = RNDIS_INITIALIZED; | |
839 | } | |
840 | return 0; | |
841 | ||
842 | case OID_802_3_MULTICAST_LIST: | |
843 | return 0; | |
844 | } | |
845 | return -1; | |
846 | } | |
847 | ||
848 | static int rndis_get_response(USBNetState *s, uint8_t *buf) | |
849 | { | |
850 | int ret = 0; | |
851 | struct rndis_response *r = s->rndis_resp.tqh_first; | |
852 | ||
853 | if (!r) | |
854 | return ret; | |
855 | ||
72cf2d4f | 856 | QTAILQ_REMOVE(&s->rndis_resp, r, entries); |
6c9f886c AZ |
857 | ret = r->length; |
858 | memcpy(buf, r->buf, r->length); | |
7267c094 | 859 | g_free(r); |
6c9f886c AZ |
860 | |
861 | return ret; | |
862 | } | |
863 | ||
864 | static void *rndis_queue_response(USBNetState *s, unsigned int length) | |
865 | { | |
866 | struct rndis_response *r = | |
7267c094 | 867 | g_malloc0(sizeof(struct rndis_response) + length); |
6c9f886c | 868 | |
8beba930 | 869 | if (QTAILQ_EMPTY(&s->rndis_resp)) { |
8550a02d | 870 | usb_wakeup(s->intr, 0); |
8beba930 HG |
871 | } |
872 | ||
72cf2d4f | 873 | QTAILQ_INSERT_TAIL(&s->rndis_resp, r, entries); |
6c9f886c AZ |
874 | r->length = length; |
875 | ||
876 | return &r->buf[0]; | |
877 | } | |
878 | ||
879 | static void rndis_clear_responsequeue(USBNetState *s) | |
880 | { | |
881 | struct rndis_response *r; | |
882 | ||
883 | while ((r = s->rndis_resp.tqh_first)) { | |
72cf2d4f | 884 | QTAILQ_REMOVE(&s->rndis_resp, r, entries); |
7267c094 | 885 | g_free(r); |
6c9f886c AZ |
886 | } |
887 | } | |
888 | ||
889 | static int rndis_init_response(USBNetState *s, rndis_init_msg_type *buf) | |
890 | { | |
891 | rndis_init_cmplt_type *resp = | |
892 | rndis_queue_response(s, sizeof(rndis_init_cmplt_type)); | |
893 | ||
894 | if (!resp) | |
895 | return USB_RET_STALL; | |
896 | ||
897 | resp->MessageType = cpu_to_le32(RNDIS_INITIALIZE_CMPLT); | |
898 | resp->MessageLength = cpu_to_le32(sizeof(rndis_init_cmplt_type)); | |
899 | resp->RequestID = buf->RequestID; /* Still LE in msg buffer */ | |
900 | resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS); | |
901 | resp->MajorVersion = cpu_to_le32(RNDIS_MAJOR_VERSION); | |
902 | resp->MinorVersion = cpu_to_le32(RNDIS_MINOR_VERSION); | |
903 | resp->DeviceFlags = cpu_to_le32(RNDIS_DF_CONNECTIONLESS); | |
904 | resp->Medium = cpu_to_le32(RNDIS_MEDIUM_802_3); | |
905 | resp->MaxPacketsPerTransfer = cpu_to_le32(1); | |
906 | resp->MaxTransferSize = cpu_to_le32(ETH_FRAME_LEN + | |
907 | sizeof(struct rndis_packet_msg_type) + 22); | |
908 | resp->PacketAlignmentFactor = cpu_to_le32(0); | |
909 | resp->AFListOffset = cpu_to_le32(0); | |
910 | resp->AFListSize = cpu_to_le32(0); | |
911 | return 0; | |
912 | } | |
913 | ||
914 | static int rndis_query_response(USBNetState *s, | |
915 | rndis_query_msg_type *buf, unsigned int length) | |
916 | { | |
917 | rndis_query_cmplt_type *resp; | |
918 | /* oid_supported_list is the largest data reply */ | |
919 | uint8_t infobuf[sizeof(oid_supported_list)]; | |
920 | uint32_t bufoffs, buflen; | |
921 | int infobuflen; | |
922 | unsigned int resplen; | |
923 | ||
924 | bufoffs = le32_to_cpu(buf->InformationBufferOffset) + 8; | |
925 | buflen = le32_to_cpu(buf->InformationBufferLength); | |
fe3c546c | 926 | if (buflen > length || bufoffs >= length || bufoffs + buflen > length) { |
6c9f886c | 927 | return USB_RET_STALL; |
fe3c546c | 928 | } |
6c9f886c AZ |
929 | |
930 | infobuflen = ndis_query(s, le32_to_cpu(buf->OID), | |
363a37d5 BS |
931 | bufoffs + (uint8_t *) buf, buflen, infobuf, |
932 | sizeof(infobuf)); | |
6c9f886c AZ |
933 | resplen = sizeof(rndis_query_cmplt_type) + |
934 | ((infobuflen < 0) ? 0 : infobuflen); | |
935 | resp = rndis_queue_response(s, resplen); | |
936 | if (!resp) | |
937 | return USB_RET_STALL; | |
938 | ||
939 | resp->MessageType = cpu_to_le32(RNDIS_QUERY_CMPLT); | |
940 | resp->RequestID = buf->RequestID; /* Still LE in msg buffer */ | |
941 | resp->MessageLength = cpu_to_le32(resplen); | |
942 | ||
943 | if (infobuflen < 0) { | |
944 | /* OID not supported */ | |
945 | resp->Status = cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED); | |
946 | resp->InformationBufferLength = cpu_to_le32(0); | |
947 | resp->InformationBufferOffset = cpu_to_le32(0); | |
948 | return 0; | |
949 | } | |
950 | ||
951 | resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS); | |
952 | resp->InformationBufferOffset = | |
953 | cpu_to_le32(infobuflen ? sizeof(rndis_query_cmplt_type) - 8 : 0); | |
954 | resp->InformationBufferLength = cpu_to_le32(infobuflen); | |
955 | memcpy(resp + 1, infobuf, infobuflen); | |
956 | ||
957 | return 0; | |
958 | } | |
959 | ||
960 | static int rndis_set_response(USBNetState *s, | |
961 | rndis_set_msg_type *buf, unsigned int length) | |
962 | { | |
963 | rndis_set_cmplt_type *resp = | |
964 | rndis_queue_response(s, sizeof(rndis_set_cmplt_type)); | |
965 | uint32_t bufoffs, buflen; | |
966 | int ret; | |
967 | ||
968 | if (!resp) | |
969 | return USB_RET_STALL; | |
970 | ||
971 | bufoffs = le32_to_cpu(buf->InformationBufferOffset) + 8; | |
972 | buflen = le32_to_cpu(buf->InformationBufferLength); | |
fe3c546c | 973 | if (buflen > length || bufoffs >= length || bufoffs + buflen > length) { |
6c9f886c | 974 | return USB_RET_STALL; |
fe3c546c | 975 | } |
6c9f886c AZ |
976 | |
977 | ret = ndis_set(s, le32_to_cpu(buf->OID), | |
978 | bufoffs + (uint8_t *) buf, buflen); | |
979 | resp->MessageType = cpu_to_le32(RNDIS_SET_CMPLT); | |
980 | resp->RequestID = buf->RequestID; /* Still LE in msg buffer */ | |
981 | resp->MessageLength = cpu_to_le32(sizeof(rndis_set_cmplt_type)); | |
982 | if (ret < 0) { | |
983 | /* OID not supported */ | |
984 | resp->Status = cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED); | |
985 | return 0; | |
986 | } | |
987 | resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS); | |
988 | ||
989 | return 0; | |
990 | } | |
991 | ||
992 | static int rndis_reset_response(USBNetState *s, rndis_reset_msg_type *buf) | |
993 | { | |
994 | rndis_reset_cmplt_type *resp = | |
995 | rndis_queue_response(s, sizeof(rndis_reset_cmplt_type)); | |
996 | ||
997 | if (!resp) | |
998 | return USB_RET_STALL; | |
999 | ||
1000 | resp->MessageType = cpu_to_le32(RNDIS_RESET_CMPLT); | |
1001 | resp->MessageLength = cpu_to_le32(sizeof(rndis_reset_cmplt_type)); | |
1002 | resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS); | |
1003 | resp->AddressingReset = cpu_to_le32(1); /* reset information */ | |
1004 | ||
1005 | return 0; | |
1006 | } | |
1007 | ||
1008 | static int rndis_keepalive_response(USBNetState *s, | |
1009 | rndis_keepalive_msg_type *buf) | |
1010 | { | |
1011 | rndis_keepalive_cmplt_type *resp = | |
1012 | rndis_queue_response(s, sizeof(rndis_keepalive_cmplt_type)); | |
1013 | ||
1014 | if (!resp) | |
1015 | return USB_RET_STALL; | |
1016 | ||
1017 | resp->MessageType = cpu_to_le32(RNDIS_KEEPALIVE_CMPLT); | |
1018 | resp->MessageLength = cpu_to_le32(sizeof(rndis_keepalive_cmplt_type)); | |
1019 | resp->RequestID = buf->RequestID; /* Still LE in msg buffer */ | |
1020 | resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS); | |
1021 | ||
1022 | return 0; | |
1023 | } | |
1024 | ||
190563f9 SH |
1025 | /* Prepare to receive the next packet */ |
1026 | static void usb_net_reset_in_buf(USBNetState *s) | |
1027 | { | |
1028 | s->in_ptr = s->in_len = 0; | |
b356f76d | 1029 | qemu_flush_queued_packets(qemu_get_queue(s->nic)); |
190563f9 SH |
1030 | } |
1031 | ||
6c9f886c AZ |
1032 | static int rndis_parse(USBNetState *s, uint8_t *data, int length) |
1033 | { | |
ec9125bc | 1034 | uint32_t msg_type = ldl_le_p(data); |
6c9f886c AZ |
1035 | |
1036 | switch (msg_type) { | |
1037 | case RNDIS_INITIALIZE_MSG: | |
1038 | s->rndis_state = RNDIS_INITIALIZED; | |
1039 | return rndis_init_response(s, (rndis_init_msg_type *) data); | |
1040 | ||
1041 | case RNDIS_HALT_MSG: | |
1042 | s->rndis_state = RNDIS_UNINITIALIZED; | |
1043 | return 0; | |
1044 | ||
1045 | case RNDIS_QUERY_MSG: | |
1046 | return rndis_query_response(s, (rndis_query_msg_type *) data, length); | |
1047 | ||
1048 | case RNDIS_SET_MSG: | |
1049 | return rndis_set_response(s, (rndis_set_msg_type *) data, length); | |
1050 | ||
1051 | case RNDIS_RESET_MSG: | |
1052 | rndis_clear_responsequeue(s); | |
190563f9 SH |
1053 | s->out_ptr = 0; |
1054 | usb_net_reset_in_buf(s); | |
6c9f886c AZ |
1055 | return rndis_reset_response(s, (rndis_reset_msg_type *) data); |
1056 | ||
1057 | case RNDIS_KEEPALIVE_MSG: | |
1058 | /* For USB: host does this every 5 seconds */ | |
1059 | return rndis_keepalive_response(s, (rndis_keepalive_msg_type *) data); | |
1060 | } | |
1061 | ||
1062 | return USB_RET_STALL; | |
1063 | } | |
1064 | ||
1065 | static void usb_net_handle_reset(USBDevice *dev) | |
1066 | { | |
1067 | } | |
1068 | ||
9a77a0f5 | 1069 | static void usb_net_handle_control(USBDevice *dev, USBPacket *p, |
007fd62f | 1070 | int request, int value, int index, int length, uint8_t *data) |
6c9f886c AZ |
1071 | { |
1072 | USBNetState *s = (USBNetState *) dev; | |
30c7d32a | 1073 | int ret; |
6c9f886c | 1074 | |
007fd62f | 1075 | ret = usb_desc_handle_control(dev, p, request, value, index, length, data); |
30c7d32a | 1076 | if (ret >= 0) { |
9a77a0f5 | 1077 | return; |
30c7d32a GH |
1078 | } |
1079 | ||
6c9f886c | 1080 | switch(request) { |
6c9f886c | 1081 | case ClassInterfaceOutRequest | USB_CDC_SEND_ENCAPSULATED_COMMAND: |
a980a065 | 1082 | if (!is_rndis(s) || value || index != 0) { |
6c9f886c | 1083 | goto fail; |
a980a065 | 1084 | } |
eb38c52c | 1085 | #ifdef TRAFFIC_DEBUG |
6c9f886c AZ |
1086 | { |
1087 | unsigned int i; | |
1088 | fprintf(stderr, "SEND_ENCAPSULATED_COMMAND:"); | |
1089 | for (i = 0; i < length; i++) { | |
1090 | if (!(i & 15)) | |
1091 | fprintf(stderr, "\n%04x:", i); | |
1092 | fprintf(stderr, " %02x", data[i]); | |
1093 | } | |
1094 | fprintf(stderr, "\n\n"); | |
1095 | } | |
1096 | #endif | |
1097 | ret = rndis_parse(s, data, length); | |
9a77a0f5 HG |
1098 | if (ret < 0) { |
1099 | p->status = ret; | |
1100 | } | |
6c9f886c AZ |
1101 | break; |
1102 | ||
1103 | case ClassInterfaceRequest | USB_CDC_GET_ENCAPSULATED_RESPONSE: | |
a980a065 | 1104 | if (!is_rndis(s) || value || index != 0) { |
6c9f886c | 1105 | goto fail; |
a980a065 | 1106 | } |
9a77a0f5 HG |
1107 | p->actual_length = rndis_get_response(s, data); |
1108 | if (p->actual_length == 0) { | |
6c9f886c | 1109 | data[0] = 0; |
9a77a0f5 | 1110 | p->actual_length = 1; |
6c9f886c | 1111 | } |
eb38c52c | 1112 | #ifdef TRAFFIC_DEBUG |
6c9f886c AZ |
1113 | { |
1114 | unsigned int i; | |
1115 | fprintf(stderr, "GET_ENCAPSULATED_RESPONSE:"); | |
9a77a0f5 | 1116 | for (i = 0; i < p->actual_length; i++) { |
6c9f886c AZ |
1117 | if (!(i & 15)) |
1118 | fprintf(stderr, "\n%04x:", i); | |
1119 | fprintf(stderr, " %02x", data[i]); | |
1120 | } | |
1121 | fprintf(stderr, "\n\n"); | |
1122 | } | |
1123 | #endif | |
1124 | break; | |
1125 | ||
6c9f886c AZ |
1126 | default: |
1127 | fail: | |
1128 | fprintf(stderr, "usbnet: failed control transaction: " | |
1129 | "request 0x%x value 0x%x index 0x%x length 0x%x\n", | |
1130 | request, value, index, length); | |
9a77a0f5 | 1131 | p->status = USB_RET_STALL; |
6c9f886c AZ |
1132 | break; |
1133 | } | |
6c9f886c AZ |
1134 | } |
1135 | ||
9a77a0f5 | 1136 | static void usb_net_handle_statusin(USBNetState *s, USBPacket *p) |
6c9f886c | 1137 | { |
4f4321c1 | 1138 | le32 buf[2]; |
6c9f886c | 1139 | |
4f4321c1 | 1140 | if (p->iov.size < 8) { |
9a77a0f5 HG |
1141 | p->status = USB_RET_STALL; |
1142 | return; | |
4f4321c1 | 1143 | } |
6c9f886c | 1144 | |
4f4321c1 GH |
1145 | buf[0] = cpu_to_le32(1); |
1146 | buf[1] = cpu_to_le32(0); | |
1147 | usb_packet_copy(p, buf, 8); | |
9a77a0f5 HG |
1148 | if (!s->rndis_resp.tqh_first) { |
1149 | p->status = USB_RET_NAK; | |
1150 | } | |
6c9f886c | 1151 | |
eb38c52c | 1152 | #ifdef TRAFFIC_DEBUG |
4f4321c1 | 1153 | fprintf(stderr, "usbnet: interrupt poll len %zu return %d", |
9a77a0f5 HG |
1154 | p->iov.size, p->status); |
1155 | iov_hexdump(p->iov.iov, p->iov.niov, stderr, "usbnet", p->status); | |
6c9f886c | 1156 | #endif |
6c9f886c AZ |
1157 | } |
1158 | ||
9a77a0f5 | 1159 | static void usb_net_handle_datain(USBNetState *s, USBPacket *p) |
6c9f886c | 1160 | { |
9a77a0f5 | 1161 | int len; |
6c9f886c AZ |
1162 | |
1163 | if (s->in_ptr > s->in_len) { | |
190563f9 | 1164 | usb_net_reset_in_buf(s); |
9a77a0f5 HG |
1165 | p->status = USB_RET_NAK; |
1166 | return; | |
6c9f886c AZ |
1167 | } |
1168 | if (!s->in_len) { | |
9a77a0f5 HG |
1169 | p->status = USB_RET_NAK; |
1170 | return; | |
6c9f886c | 1171 | } |
9a77a0f5 HG |
1172 | len = s->in_len - s->in_ptr; |
1173 | if (len > p->iov.size) { | |
1174 | len = p->iov.size; | |
4f4321c1 | 1175 | } |
9a77a0f5 HG |
1176 | usb_packet_copy(p, &s->in_buf[s->in_ptr], len); |
1177 | s->in_ptr += len; | |
6c9f886c | 1178 | if (s->in_ptr >= s->in_len && |
9a77a0f5 | 1179 | (is_rndis(s) || (s->in_len & (64 - 1)) || !len)) { |
6c9f886c | 1180 | /* no short packet necessary */ |
190563f9 | 1181 | usb_net_reset_in_buf(s); |
6c9f886c AZ |
1182 | } |
1183 | ||
eb38c52c | 1184 | #ifdef TRAFFIC_DEBUG |
9a77a0f5 HG |
1185 | fprintf(stderr, "usbnet: data in len %zu return %d", p->iov.size, len); |
1186 | iov_hexdump(p->iov.iov, p->iov.niov, stderr, "usbnet", len); | |
6c9f886c | 1187 | #endif |
6c9f886c AZ |
1188 | } |
1189 | ||
9a77a0f5 | 1190 | static void usb_net_handle_dataout(USBNetState *s, USBPacket *p) |
6c9f886c | 1191 | { |
6c9f886c AZ |
1192 | int sz = sizeof(s->out_buf) - s->out_ptr; |
1193 | struct rndis_packet_msg_type *msg = | |
1194 | (struct rndis_packet_msg_type *) s->out_buf; | |
1195 | uint32_t len; | |
1196 | ||
eb38c52c | 1197 | #ifdef TRAFFIC_DEBUG |
4f4321c1 GH |
1198 | fprintf(stderr, "usbnet: data out len %zu\n", p->iov.size); |
1199 | iov_hexdump(p->iov.iov, p->iov.niov, stderr, "usbnet", p->iov.size); | |
6c9f886c AZ |
1200 | #endif |
1201 | ||
9a77a0f5 HG |
1202 | if (sz > p->iov.size) { |
1203 | sz = p->iov.size; | |
1204 | } | |
4f4321c1 | 1205 | usb_packet_copy(p, &s->out_buf[s->out_ptr], sz); |
6c9f886c AZ |
1206 | s->out_ptr += sz; |
1207 | ||
a980a065 | 1208 | if (!is_rndis(s)) { |
9a77a0f5 | 1209 | if (p->iov.size < 64) { |
b356f76d | 1210 | qemu_send_packet(qemu_get_queue(s->nic), s->out_buf, s->out_ptr); |
6c9f886c AZ |
1211 | s->out_ptr = 0; |
1212 | } | |
9a77a0f5 | 1213 | return; |
6c9f886c AZ |
1214 | } |
1215 | len = le32_to_cpu(msg->MessageLength); | |
9a77a0f5 HG |
1216 | if (s->out_ptr < 8 || s->out_ptr < len) { |
1217 | return; | |
1218 | } | |
6c9f886c AZ |
1219 | if (le32_to_cpu(msg->MessageType) == RNDIS_PACKET_MSG) { |
1220 | uint32_t offs = 8 + le32_to_cpu(msg->DataOffset); | |
1221 | uint32_t size = le32_to_cpu(msg->DataLength); | |
fe3c546c | 1222 | if (offs < len && size < len && offs + size <= len) { |
b356f76d | 1223 | qemu_send_packet(qemu_get_queue(s->nic), s->out_buf + offs, size); |
fe3c546c | 1224 | } |
6c9f886c AZ |
1225 | } |
1226 | s->out_ptr -= len; | |
1227 | memmove(s->out_buf, &s->out_buf[len], s->out_ptr); | |
6c9f886c AZ |
1228 | } |
1229 | ||
9a77a0f5 | 1230 | static void usb_net_handle_data(USBDevice *dev, USBPacket *p) |
6c9f886c AZ |
1231 | { |
1232 | USBNetState *s = (USBNetState *) dev; | |
6c9f886c AZ |
1233 | |
1234 | switch(p->pid) { | |
1235 | case USB_TOKEN_IN: | |
079d0b7f | 1236 | switch (p->ep->nr) { |
6c9f886c | 1237 | case 1: |
9a77a0f5 | 1238 | usb_net_handle_statusin(s, p); |
6c9f886c AZ |
1239 | break; |
1240 | ||
1241 | case 2: | |
9a77a0f5 | 1242 | usb_net_handle_datain(s, p); |
6c9f886c AZ |
1243 | break; |
1244 | ||
1245 | default: | |
1246 | goto fail; | |
1247 | } | |
1248 | break; | |
1249 | ||
1250 | case USB_TOKEN_OUT: | |
079d0b7f | 1251 | switch (p->ep->nr) { |
6c9f886c | 1252 | case 2: |
9a77a0f5 | 1253 | usb_net_handle_dataout(s, p); |
6c9f886c AZ |
1254 | break; |
1255 | ||
1256 | default: | |
1257 | goto fail; | |
1258 | } | |
1259 | break; | |
1260 | ||
1261 | default: | |
1262 | fail: | |
9a77a0f5 | 1263 | p->status = USB_RET_STALL; |
6c9f886c AZ |
1264 | break; |
1265 | } | |
9a77a0f5 HG |
1266 | |
1267 | if (p->status == USB_RET_STALL) { | |
6c9f886c | 1268 | fprintf(stderr, "usbnet: failed data transaction: " |
4f4321c1 | 1269 | "pid 0x%x ep 0x%x len 0x%zx\n", |
079d0b7f | 1270 | p->pid, p->ep->nr, p->iov.size); |
9a77a0f5 | 1271 | } |
6c9f886c AZ |
1272 | } |
1273 | ||
4e68f7a0 | 1274 | static ssize_t usbnet_receive(NetClientState *nc, const uint8_t *buf, size_t size) |
6c9f886c | 1275 | { |
cc1f0f45 | 1276 | USBNetState *s = qemu_get_nic_opaque(nc); |
f237ddbb SH |
1277 | uint8_t *in_buf = s->in_buf; |
1278 | size_t total_size = size; | |
6c9f886c | 1279 | |
91344024 FZ |
1280 | if (!s->dev.config) { |
1281 | return -1; | |
1282 | } | |
1283 | ||
a980a065 | 1284 | if (is_rndis(s)) { |
98d23704 | 1285 | if (s->rndis_state != RNDIS_DATA_INITIALIZED) { |
4f1c942b | 1286 | return -1; |
98d23704 | 1287 | } |
f237ddbb SH |
1288 | total_size += sizeof(struct rndis_packet_msg_type); |
1289 | } | |
1290 | if (total_size > sizeof(s->in_buf)) { | |
1291 | return -1; | |
1292 | } | |
6c9f886c | 1293 | |
190563f9 SH |
1294 | /* Only accept packet if input buffer is empty */ |
1295 | if (s->in_len > 0) { | |
1296 | return 0; | |
1297 | } | |
1298 | ||
f237ddbb SH |
1299 | if (is_rndis(s)) { |
1300 | struct rndis_packet_msg_type *msg; | |
1301 | ||
1302 | msg = (struct rndis_packet_msg_type *)in_buf; | |
6c9f886c AZ |
1303 | memset(msg, 0, sizeof(struct rndis_packet_msg_type)); |
1304 | msg->MessageType = cpu_to_le32(RNDIS_PACKET_MSG); | |
f237ddbb SH |
1305 | msg->MessageLength = cpu_to_le32(size + sizeof(*msg)); |
1306 | msg->DataOffset = cpu_to_le32(sizeof(*msg) - 8); | |
6c9f886c AZ |
1307 | msg->DataLength = cpu_to_le32(size); |
1308 | /* msg->OOBDataOffset; | |
1309 | * msg->OOBDataLength; | |
1310 | * msg->NumOOBDataElements; | |
1311 | * msg->PerPacketInfoOffset; | |
1312 | * msg->PerPacketInfoLength; | |
1313 | * msg->VcHandle; | |
1314 | * msg->Reserved; | |
1315 | */ | |
f237ddbb | 1316 | in_buf += sizeof(*msg); |
6c9f886c | 1317 | } |
f237ddbb SH |
1318 | |
1319 | memcpy(in_buf, buf, size); | |
1320 | s->in_len = total_size; | |
6c9f886c | 1321 | s->in_ptr = 0; |
4f1c942b | 1322 | return size; |
6c9f886c AZ |
1323 | } |
1324 | ||
4e68f7a0 | 1325 | static void usbnet_cleanup(NetClientState *nc) |
b946a153 | 1326 | { |
cc1f0f45 | 1327 | USBNetState *s = qemu_get_nic_opaque(nc); |
b946a153 | 1328 | |
42be86ce | 1329 | s->nic = NULL; |
b946a153 AL |
1330 | } |
1331 | ||
b69c3c21 | 1332 | static void usb_net_unrealize(USBDevice *dev) |
6c9f886c AZ |
1333 | { |
1334 | USBNetState *s = (USBNetState *) dev; | |
1335 | ||
dcf414d6 | 1336 | /* TODO: remove the nd_table[] entry */ |
42be86ce | 1337 | rndis_clear_responsequeue(s); |
948ecf21 | 1338 | qemu_del_nic(s->nic); |
6c9f886c AZ |
1339 | } |
1340 | ||
42be86ce | 1341 | static NetClientInfo net_usbnet_info = { |
f394b2e2 | 1342 | .type = NET_CLIENT_DRIVER_NIC, |
42be86ce | 1343 | .size = sizeof(NICState), |
42be86ce GH |
1344 | .receive = usbnet_receive, |
1345 | .cleanup = usbnet_cleanup, | |
1346 | }; | |
1347 | ||
a5fee60d | 1348 | static void usb_net_realize(USBDevice *dev, Error **errp) |
6c9f886c | 1349 | { |
fe47db72 | 1350 | USBNetState *s = USB_NET(dev); |
6c9f886c | 1351 | |
9d55d1ad | 1352 | usb_desc_create_serial(dev); |
a980a065 | 1353 | usb_desc_init(dev); |
6c9f886c | 1354 | |
6c9f886c | 1355 | s->rndis_state = RNDIS_UNINITIALIZED; |
72cf2d4f | 1356 | QTAILQ_INIT(&s->rndis_resp); |
806b6024 | 1357 | |
6c9f886c AZ |
1358 | s->medium = 0; /* NDIS_MEDIUM_802_3 */ |
1359 | s->speed = 1000000; /* 100MBps, in 100Bps units */ | |
1360 | s->media_state = 0; /* NDIS_MEDIA_STATE_CONNECTED */; | |
1361 | s->filter = 0; | |
1362 | s->vendorid = 0x1234; | |
8beba930 | 1363 | s->intr = usb_ep_get(dev, USB_TOKEN_IN, 1); |
42be86ce GH |
1364 | |
1365 | qemu_macaddr_default_if_unset(&s->conf.macaddr); | |
1366 | s->nic = qemu_new_nic(&net_usbnet_info, &s->conf, | |
f79f2bfc | 1367 | object_get_typename(OBJECT(s)), s->dev.qdev.id, s); |
b356f76d | 1368 | qemu_format_nic_info_str(qemu_get_queue(s->nic), s->conf.macaddr.a); |
42be86ce GH |
1369 | snprintf(s->usbstring_mac, sizeof(s->usbstring_mac), |
1370 | "%02x%02x%02x%02x%02x%02x", | |
1371 | 0x40, | |
1372 | s->conf.macaddr.a[1], | |
1373 | s->conf.macaddr.a[2], | |
1374 | s->conf.macaddr.a[3], | |
1375 | s->conf.macaddr.a[4], | |
1376 | s->conf.macaddr.a[5]); | |
30c7d32a | 1377 | usb_desc_set_string(dev, STRING_ETHADDR, s->usbstring_mac); |
806b6024 GH |
1378 | } |
1379 | ||
c11f4bc9 GA |
1380 | static void usb_net_instance_init(Object *obj) |
1381 | { | |
1382 | USBDevice *dev = USB_DEVICE(obj); | |
fe47db72 | 1383 | USBNetState *s = USB_NET(dev); |
c11f4bc9 GA |
1384 | |
1385 | device_add_bootindex_property(obj, &s->conf.bootindex, | |
1386 | "bootindex", "/ethernet-phy@0", | |
40c2281c | 1387 | &dev->qdev); |
c11f4bc9 GA |
1388 | } |
1389 | ||
4ab0ba9e GH |
1390 | static const VMStateDescription vmstate_usb_net = { |
1391 | .name = "usb-net", | |
1392 | .unmigratable = 1, | |
1393 | }; | |
1394 | ||
39bffca2 AL |
1395 | static Property net_properties[] = { |
1396 | DEFINE_NIC_PROPERTIES(USBNetState, conf), | |
1397 | DEFINE_PROP_END_OF_LIST(), | |
1398 | }; | |
1399 | ||
62aed765 AL |
1400 | static void usb_net_class_initfn(ObjectClass *klass, void *data) |
1401 | { | |
39bffca2 | 1402 | DeviceClass *dc = DEVICE_CLASS(klass); |
62aed765 AL |
1403 | USBDeviceClass *uc = USB_DEVICE_CLASS(klass); |
1404 | ||
d73ad359 | 1405 | uc->realize = usb_net_realize; |
62aed765 AL |
1406 | uc->product_desc = "QEMU USB Network Interface"; |
1407 | uc->usb_desc = &desc_net; | |
62aed765 AL |
1408 | uc->handle_reset = usb_net_handle_reset; |
1409 | uc->handle_control = usb_net_handle_control; | |
1410 | uc->handle_data = usb_net_handle_data; | |
c4fe9700 | 1411 | uc->unrealize = usb_net_unrealize; |
125ee0ed | 1412 | set_bit(DEVICE_CATEGORY_NETWORK, dc->categories); |
39bffca2 AL |
1413 | dc->fw_name = "network"; |
1414 | dc->vmsd = &vmstate_usb_net; | |
4f67d30b | 1415 | device_class_set_props(dc, net_properties); |
62aed765 AL |
1416 | } |
1417 | ||
8c43a6f0 | 1418 | static const TypeInfo net_info = { |
fe47db72 | 1419 | .name = TYPE_USB_NET, |
39bffca2 AL |
1420 | .parent = TYPE_USB_DEVICE, |
1421 | .instance_size = sizeof(USBNetState), | |
1422 | .class_init = usb_net_class_initfn, | |
c11f4bc9 | 1423 | .instance_init = usb_net_instance_init, |
806b6024 GH |
1424 | }; |
1425 | ||
83f7d43a | 1426 | static void usb_net_register_types(void) |
806b6024 | 1427 | { |
39bffca2 | 1428 | type_register_static(&net_info); |
806b6024 | 1429 | } |
83f7d43a AF |
1430 | |
1431 | type_init(usb_net_register_types) |