4 * Copyright (c) 2006 Thomas Sailer
5 * Copyright (c) 2008 Andrzej Zaborowski
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:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
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
26 #include "qemu/osdep.h"
27 #include "qapi/error.h"
29 #include "migration/vmstate.h"
32 #include "qemu/error-report.h"
33 #include "qemu/queue.h"
34 #include "qemu/config-file.h"
35 #include "sysemu/sysemu.h"
37 #include "qemu/module.h"
38 #include "qemu/cutils.h"
40 /*#define TRAFFIC_DEBUG*/
41 /* Thanks to NetChip Technologies for donating this product ID.
42 * It's for devices with only CDC Ethernet configurations.
44 #define CDC_VENDOR_NUM 0x0525 /* NetChip */
45 #define CDC_PRODUCT_NUM 0xa4a1 /* Linux-USB Ethernet Gadget */
46 /* For hardware that can talk RNDIS and either of the above protocols,
47 * use this ID ... the windows INF files will know it.
49 #define RNDIS_VENDOR_NUM 0x0525 /* NetChip */
50 #define RNDIS_PRODUCT_NUM 0xa4a2 /* Ethernet/RNDIS Gadget */
53 STRING_MANUFACTURER
= 1,
65 #define DEV_CONFIG_VALUE 1 /* CDC or a subset */
66 #define DEV_RNDIS_CONFIG_VALUE 2 /* RNDIS; optional */
68 #define USB_CDC_SUBCLASS_ACM 0x02
69 #define USB_CDC_SUBCLASS_ETHERNET 0x06
71 #define USB_CDC_PROTO_NONE 0
72 #define USB_CDC_ACM_PROTO_VENDOR 0xff
74 #define USB_CDC_HEADER_TYPE 0x00 /* header_desc */
75 #define USB_CDC_CALL_MANAGEMENT_TYPE 0x01 /* call_mgmt_descriptor */
76 #define USB_CDC_ACM_TYPE 0x02 /* acm_descriptor */
77 #define USB_CDC_UNION_TYPE 0x06 /* union_desc */
78 #define USB_CDC_ETHERNET_TYPE 0x0f /* ether_desc */
80 #define USB_CDC_SEND_ENCAPSULATED_COMMAND 0x00
81 #define USB_CDC_GET_ENCAPSULATED_RESPONSE 0x01
82 #define USB_CDC_REQ_SET_LINE_CODING 0x20
83 #define USB_CDC_REQ_GET_LINE_CODING 0x21
84 #define USB_CDC_REQ_SET_CONTROL_LINE_STATE 0x22
85 #define USB_CDC_REQ_SEND_BREAK 0x23
86 #define USB_CDC_SET_ETHERNET_MULTICAST_FILTERS 0x40
87 #define USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER 0x41
88 #define USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER 0x42
89 #define USB_CDC_SET_ETHERNET_PACKET_FILTER 0x43
90 #define USB_CDC_GET_ETHERNET_STATISTIC 0x44
92 #define LOG2_STATUS_INTERVAL_MSEC 5 /* 1 << 5 == 32 msec */
93 #define STATUS_BYTECOUNT 16 /* 8 byte header + data */
95 #define ETH_FRAME_LEN 1514 /* Max. octets in frame sans FCS */
97 static const USBDescStrings usb_net_stringtable
= {
98 [STRING_MANUFACTURER
] = "QEMU",
99 [STRING_PRODUCT
] = "RNDIS/QEMU USB Network Device",
100 [STRING_ETHADDR
] = "400102030405",
101 [STRING_DATA
] = "QEMU USB Net Data Interface",
102 [STRING_CONTROL
] = "QEMU USB Net Control Interface",
103 [STRING_RNDIS_CONTROL
] = "QEMU USB Net RNDIS Control Interface",
104 [STRING_CDC
] = "QEMU USB Net CDC",
105 [STRING_SUBSET
] = "QEMU USB Net Subset",
106 [STRING_RNDIS
] = "QEMU USB Net RNDIS",
107 [STRING_SERIALNUMBER
] = "1",
110 static const USBDescIface desc_iface_rndis
[] = {
112 /* RNDIS Control Interface */
113 .bInterfaceNumber
= 0,
115 .bInterfaceClass
= USB_CLASS_COMM
,
116 .bInterfaceSubClass
= USB_CDC_SUBCLASS_ACM
,
117 .bInterfaceProtocol
= USB_CDC_ACM_PROTO_VENDOR
,
118 .iInterface
= STRING_RNDIS_CONTROL
,
120 .descs
= (USBDescOther
[]) {
122 /* Header Descriptor */
123 .data
= (uint8_t[]) {
124 0x05, /* u8 bLength */
125 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
126 USB_CDC_HEADER_TYPE
, /* u8 bDescriptorSubType */
127 0x10, 0x01, /* le16 bcdCDC */
130 /* Call Management Descriptor */
131 .data
= (uint8_t[]) {
132 0x05, /* u8 bLength */
133 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
134 USB_CDC_CALL_MANAGEMENT_TYPE
, /* u8 bDescriptorSubType */
135 0x00, /* u8 bmCapabilities */
136 0x01, /* u8 bDataInterface */
140 .data
= (uint8_t[]) {
141 0x04, /* u8 bLength */
142 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
143 USB_CDC_ACM_TYPE
, /* u8 bDescriptorSubType */
144 0x00, /* u8 bmCapabilities */
147 /* Union Descriptor */
148 .data
= (uint8_t[]) {
149 0x05, /* u8 bLength */
150 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
151 USB_CDC_UNION_TYPE
, /* u8 bDescriptorSubType */
152 0x00, /* u8 bMasterInterface0 */
153 0x01, /* u8 bSlaveInterface0 */
157 .eps
= (USBDescEndpoint
[]) {
159 .bEndpointAddress
= USB_DIR_IN
| 0x01,
160 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
161 .wMaxPacketSize
= STATUS_BYTECOUNT
,
162 .bInterval
= 1 << LOG2_STATUS_INTERVAL_MSEC
,
166 /* RNDIS Data Interface */
167 .bInterfaceNumber
= 1,
169 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
170 .iInterface
= STRING_DATA
,
171 .eps
= (USBDescEndpoint
[]) {
173 .bEndpointAddress
= USB_DIR_IN
| 0x02,
174 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
175 .wMaxPacketSize
= 0x40,
177 .bEndpointAddress
= USB_DIR_OUT
| 0x02,
178 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
179 .wMaxPacketSize
= 0x40,
185 static const USBDescIface desc_iface_cdc
[] = {
187 /* CDC Control Interface */
188 .bInterfaceNumber
= 0,
190 .bInterfaceClass
= USB_CLASS_COMM
,
191 .bInterfaceSubClass
= USB_CDC_SUBCLASS_ETHERNET
,
192 .bInterfaceProtocol
= USB_CDC_PROTO_NONE
,
193 .iInterface
= STRING_CONTROL
,
195 .descs
= (USBDescOther
[]) {
197 /* Header Descriptor */
198 .data
= (uint8_t[]) {
199 0x05, /* u8 bLength */
200 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
201 USB_CDC_HEADER_TYPE
, /* u8 bDescriptorSubType */
202 0x10, 0x01, /* le16 bcdCDC */
205 /* Union Descriptor */
206 .data
= (uint8_t[]) {
207 0x05, /* u8 bLength */
208 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
209 USB_CDC_UNION_TYPE
, /* u8 bDescriptorSubType */
210 0x00, /* u8 bMasterInterface0 */
211 0x01, /* u8 bSlaveInterface0 */
214 /* Ethernet Descriptor */
215 .data
= (uint8_t[]) {
216 0x0d, /* u8 bLength */
217 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
218 USB_CDC_ETHERNET_TYPE
, /* u8 bDescriptorSubType */
219 STRING_ETHADDR
, /* u8 iMACAddress */
220 0x00, 0x00, 0x00, 0x00, /* le32 bmEthernetStatistics */
221 ETH_FRAME_LEN
& 0xff,
222 ETH_FRAME_LEN
>> 8, /* le16 wMaxSegmentSize */
223 0x00, 0x00, /* le16 wNumberMCFilters */
224 0x00, /* u8 bNumberPowerFilters */
228 .eps
= (USBDescEndpoint
[]) {
230 .bEndpointAddress
= USB_DIR_IN
| 0x01,
231 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
232 .wMaxPacketSize
= STATUS_BYTECOUNT
,
233 .bInterval
= 1 << LOG2_STATUS_INTERVAL_MSEC
,
237 /* CDC Data Interface (off) */
238 .bInterfaceNumber
= 1,
239 .bAlternateSetting
= 0,
241 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
243 /* CDC Data Interface */
244 .bInterfaceNumber
= 1,
245 .bAlternateSetting
= 1,
247 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
248 .iInterface
= STRING_DATA
,
249 .eps
= (USBDescEndpoint
[]) {
251 .bEndpointAddress
= USB_DIR_IN
| 0x02,
252 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
253 .wMaxPacketSize
= 0x40,
255 .bEndpointAddress
= USB_DIR_OUT
| 0x02,
256 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
257 .wMaxPacketSize
= 0x40,
263 static const USBDescDevice desc_device_net
= {
265 .bDeviceClass
= USB_CLASS_COMM
,
266 .bMaxPacketSize0
= 0x40,
267 .bNumConfigurations
= 2,
268 .confs
= (USBDescConfig
[]) {
271 .bConfigurationValue
= DEV_RNDIS_CONFIG_VALUE
,
272 .iConfiguration
= STRING_RNDIS
,
273 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_SELFPOWER
,
275 .nif
= ARRAY_SIZE(desc_iface_rndis
),
276 .ifs
= desc_iface_rndis
,
279 .bConfigurationValue
= DEV_CONFIG_VALUE
,
280 .iConfiguration
= STRING_CDC
,
281 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_SELFPOWER
,
283 .nif
= ARRAY_SIZE(desc_iface_cdc
),
284 .ifs
= desc_iface_cdc
,
289 static const USBDesc desc_net
= {
291 .idVendor
= RNDIS_VENDOR_NUM
,
292 .idProduct
= RNDIS_PRODUCT_NUM
,
294 .iManufacturer
= STRING_MANUFACTURER
,
295 .iProduct
= STRING_PRODUCT
,
296 .iSerialNumber
= STRING_SERIALNUMBER
,
298 .full
= &desc_device_net
,
299 .str
= usb_net_stringtable
,
303 * RNDIS Definitions - in theory not specific to USB.
305 #define RNDIS_MAXIMUM_FRAME_SIZE 1518
306 #define RNDIS_MAX_TOTAL_SIZE 1558
308 /* Remote NDIS Versions */
309 #define RNDIS_MAJOR_VERSION 1
310 #define RNDIS_MINOR_VERSION 0
313 #define RNDIS_STATUS_SUCCESS 0x00000000U /* Success */
314 #define RNDIS_STATUS_FAILURE 0xc0000001U /* Unspecified error */
315 #define RNDIS_STATUS_INVALID_DATA 0xc0010015U /* Invalid data */
316 #define RNDIS_STATUS_NOT_SUPPORTED 0xc00000bbU /* Unsupported request */
317 #define RNDIS_STATUS_MEDIA_CONNECT 0x4001000bU /* Device connected */
318 #define RNDIS_STATUS_MEDIA_DISCONNECT 0x4001000cU /* Device disconnected */
320 /* Message Set for Connectionless (802.3) Devices */
322 RNDIS_PACKET_MSG
= 1,
323 RNDIS_INITIALIZE_MSG
= 2, /* Initialize device */
328 RNDIS_INDICATE_STATUS_MSG
= 7,
329 RNDIS_KEEPALIVE_MSG
= 8,
332 /* Message completion */
334 RNDIS_INITIALIZE_CMPLT
= 0x80000002U
,
335 RNDIS_QUERY_CMPLT
= 0x80000004U
,
336 RNDIS_SET_CMPLT
= 0x80000005U
,
337 RNDIS_RESET_CMPLT
= 0x80000006U
,
338 RNDIS_KEEPALIVE_CMPLT
= 0x80000008U
,
343 RNDIS_DF_CONNECTIONLESS
= 1,
344 RNDIS_DF_CONNECTIONORIENTED
= 2,
347 #define RNDIS_MEDIUM_802_3 0x00000000U
349 /* from drivers/net/sk98lin/h/skgepnmi.h */
350 #define OID_PNP_CAPABILITIES 0xfd010100
351 #define OID_PNP_SET_POWER 0xfd010101
352 #define OID_PNP_QUERY_POWER 0xfd010102
353 #define OID_PNP_ADD_WAKE_UP_PATTERN 0xfd010103
354 #define OID_PNP_REMOVE_WAKE_UP_PATTERN 0xfd010104
355 #define OID_PNP_ENABLE_WAKE_UP 0xfd010106
357 typedef uint32_t le32
;
359 typedef struct rndis_init_msg_type
{
365 le32 MaxTransferSize
;
366 } rndis_init_msg_type
;
368 typedef struct rndis_init_cmplt_type
{
377 le32 MaxPacketsPerTransfer
;
378 le32 MaxTransferSize
;
379 le32 PacketAlignmentFactor
;
382 } rndis_init_cmplt_type
;
384 typedef struct rndis_halt_msg_type
{
388 } rndis_halt_msg_type
;
390 typedef struct rndis_query_msg_type
{
395 le32 InformationBufferLength
;
396 le32 InformationBufferOffset
;
398 } rndis_query_msg_type
;
400 typedef struct rndis_query_cmplt_type
{
405 le32 InformationBufferLength
;
406 le32 InformationBufferOffset
;
407 } rndis_query_cmplt_type
;
409 typedef struct rndis_set_msg_type
{
414 le32 InformationBufferLength
;
415 le32 InformationBufferOffset
;
417 } rndis_set_msg_type
;
419 typedef struct rndis_set_cmplt_type
{
424 } rndis_set_cmplt_type
;
426 typedef struct rndis_reset_msg_type
{
430 } rndis_reset_msg_type
;
432 typedef struct rndis_reset_cmplt_type
{
436 le32 AddressingReset
;
437 } rndis_reset_cmplt_type
;
439 typedef struct rndis_indicate_status_msg_type
{
443 le32 StatusBufferLength
;
444 le32 StatusBufferOffset
;
445 } rndis_indicate_status_msg_type
;
447 typedef struct rndis_keepalive_msg_type
{
451 } rndis_keepalive_msg_type
;
453 typedef struct rndis_keepalive_cmplt_type
{
458 } rndis_keepalive_cmplt_type
;
460 struct rndis_packet_msg_type
{
467 le32 NumOOBDataElements
;
468 le32 PerPacketInfoOffset
;
469 le32 PerPacketInfoLength
;
474 struct rndis_config_parameter
{
475 le32 ParameterNameOffset
;
476 le32 ParameterNameLength
;
478 le32 ParameterValueOffset
;
479 le32 ParameterValueLength
;
482 /* implementation specific */
487 RNDIS_DATA_INITIALIZED
,
492 /* Required Object IDs (OIDs) */
493 OID_GEN_SUPPORTED_LIST
= 0x00010101,
494 OID_GEN_HARDWARE_STATUS
= 0x00010102,
495 OID_GEN_MEDIA_SUPPORTED
= 0x00010103,
496 OID_GEN_MEDIA_IN_USE
= 0x00010104,
497 OID_GEN_MAXIMUM_LOOKAHEAD
= 0x00010105,
498 OID_GEN_MAXIMUM_FRAME_SIZE
= 0x00010106,
499 OID_GEN_LINK_SPEED
= 0x00010107,
500 OID_GEN_TRANSMIT_BUFFER_SPACE
= 0x00010108,
501 OID_GEN_RECEIVE_BUFFER_SPACE
= 0x00010109,
502 OID_GEN_TRANSMIT_BLOCK_SIZE
= 0x0001010a,
503 OID_GEN_RECEIVE_BLOCK_SIZE
= 0x0001010b,
504 OID_GEN_VENDOR_ID
= 0x0001010c,
505 OID_GEN_VENDOR_DESCRIPTION
= 0x0001010d,
506 OID_GEN_CURRENT_PACKET_FILTER
= 0x0001010e,
507 OID_GEN_CURRENT_LOOKAHEAD
= 0x0001010f,
508 OID_GEN_DRIVER_VERSION
= 0x00010110,
509 OID_GEN_MAXIMUM_TOTAL_SIZE
= 0x00010111,
510 OID_GEN_PROTOCOL_OPTIONS
= 0x00010112,
511 OID_GEN_MAC_OPTIONS
= 0x00010113,
512 OID_GEN_MEDIA_CONNECT_STATUS
= 0x00010114,
513 OID_GEN_MAXIMUM_SEND_PACKETS
= 0x00010115,
514 OID_GEN_VENDOR_DRIVER_VERSION
= 0x00010116,
515 OID_GEN_SUPPORTED_GUIDS
= 0x00010117,
516 OID_GEN_NETWORK_LAYER_ADDRESSES
= 0x00010118,
517 OID_GEN_TRANSPORT_HEADER_OFFSET
= 0x00010119,
518 OID_GEN_MACHINE_NAME
= 0x0001021a,
519 OID_GEN_RNDIS_CONFIG_PARAMETER
= 0x0001021b,
520 OID_GEN_VLAN_ID
= 0x0001021c,
523 OID_GEN_MEDIA_CAPABILITIES
= 0x00010201,
524 OID_GEN_PHYSICAL_MEDIUM
= 0x00010202,
526 /* Required statistics OIDs */
527 OID_GEN_XMIT_OK
= 0x00020101,
528 OID_GEN_RCV_OK
= 0x00020102,
529 OID_GEN_XMIT_ERROR
= 0x00020103,
530 OID_GEN_RCV_ERROR
= 0x00020104,
531 OID_GEN_RCV_NO_BUFFER
= 0x00020105,
533 /* Optional statistics OIDs */
534 OID_GEN_DIRECTED_BYTES_XMIT
= 0x00020201,
535 OID_GEN_DIRECTED_FRAMES_XMIT
= 0x00020202,
536 OID_GEN_MULTICAST_BYTES_XMIT
= 0x00020203,
537 OID_GEN_MULTICAST_FRAMES_XMIT
= 0x00020204,
538 OID_GEN_BROADCAST_BYTES_XMIT
= 0x00020205,
539 OID_GEN_BROADCAST_FRAMES_XMIT
= 0x00020206,
540 OID_GEN_DIRECTED_BYTES_RCV
= 0x00020207,
541 OID_GEN_DIRECTED_FRAMES_RCV
= 0x00020208,
542 OID_GEN_MULTICAST_BYTES_RCV
= 0x00020209,
543 OID_GEN_MULTICAST_FRAMES_RCV
= 0x0002020a,
544 OID_GEN_BROADCAST_BYTES_RCV
= 0x0002020b,
545 OID_GEN_BROADCAST_FRAMES_RCV
= 0x0002020c,
546 OID_GEN_RCV_CRC_ERROR
= 0x0002020d,
547 OID_GEN_TRANSMIT_QUEUE_LENGTH
= 0x0002020e,
548 OID_GEN_GET_TIME_CAPS
= 0x0002020f,
549 OID_GEN_GET_NETCARD_TIME
= 0x00020210,
550 OID_GEN_NETCARD_LOAD
= 0x00020211,
551 OID_GEN_DEVICE_PROFILE
= 0x00020212,
552 OID_GEN_INIT_TIME_MS
= 0x00020213,
553 OID_GEN_RESET_COUNTS
= 0x00020214,
554 OID_GEN_MEDIA_SENSE_COUNTS
= 0x00020215,
555 OID_GEN_FRIENDLY_NAME
= 0x00020216,
556 OID_GEN_MINIPORT_INFO
= 0x00020217,
557 OID_GEN_RESET_VERIFY_PARAMETERS
= 0x00020218,
559 /* IEEE 802.3 (Ethernet) OIDs */
560 OID_802_3_PERMANENT_ADDRESS
= 0x01010101,
561 OID_802_3_CURRENT_ADDRESS
= 0x01010102,
562 OID_802_3_MULTICAST_LIST
= 0x01010103,
563 OID_802_3_MAXIMUM_LIST_SIZE
= 0x01010104,
564 OID_802_3_MAC_OPTIONS
= 0x01010105,
565 OID_802_3_RCV_ERROR_ALIGNMENT
= 0x01020101,
566 OID_802_3_XMIT_ONE_COLLISION
= 0x01020102,
567 OID_802_3_XMIT_MORE_COLLISIONS
= 0x01020103,
568 OID_802_3_XMIT_DEFERRED
= 0x01020201,
569 OID_802_3_XMIT_MAX_COLLISIONS
= 0x01020202,
570 OID_802_3_RCV_OVERRUN
= 0x01020203,
571 OID_802_3_XMIT_UNDERRUN
= 0x01020204,
572 OID_802_3_XMIT_HEARTBEAT_FAILURE
= 0x01020205,
573 OID_802_3_XMIT_TIMES_CRS_LOST
= 0x01020206,
574 OID_802_3_XMIT_LATE_COLLISIONS
= 0x01020207,
577 static const uint32_t oid_supported_list
[] =
579 /* the general stuff */
580 OID_GEN_SUPPORTED_LIST
,
581 OID_GEN_HARDWARE_STATUS
,
582 OID_GEN_MEDIA_SUPPORTED
,
583 OID_GEN_MEDIA_IN_USE
,
584 OID_GEN_MAXIMUM_FRAME_SIZE
,
586 OID_GEN_TRANSMIT_BLOCK_SIZE
,
587 OID_GEN_RECEIVE_BLOCK_SIZE
,
589 OID_GEN_VENDOR_DESCRIPTION
,
590 OID_GEN_VENDOR_DRIVER_VERSION
,
591 OID_GEN_CURRENT_PACKET_FILTER
,
592 OID_GEN_MAXIMUM_TOTAL_SIZE
,
593 OID_GEN_MEDIA_CONNECT_STATUS
,
594 OID_GEN_PHYSICAL_MEDIUM
,
596 /* the statistical stuff */
601 OID_GEN_RCV_NO_BUFFER
,
604 /* the general stuff */
605 OID_802_3_PERMANENT_ADDRESS
,
606 OID_802_3_CURRENT_ADDRESS
,
607 OID_802_3_MULTICAST_LIST
,
608 OID_802_3_MAC_OPTIONS
,
609 OID_802_3_MAXIMUM_LIST_SIZE
,
611 /* the statistical stuff */
612 OID_802_3_RCV_ERROR_ALIGNMENT
,
613 OID_802_3_XMIT_ONE_COLLISION
,
614 OID_802_3_XMIT_MORE_COLLISIONS
,
617 #define NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA (1 << 0)
618 #define NDIS_MAC_OPTION_RECEIVE_SERIALIZED (1 << 1)
619 #define NDIS_MAC_OPTION_TRANSFERS_NOT_PEND (1 << 2)
620 #define NDIS_MAC_OPTION_NO_LOOPBACK (1 << 3)
621 #define NDIS_MAC_OPTION_FULL_DUPLEX (1 << 4)
622 #define NDIS_MAC_OPTION_EOTX_INDICATION (1 << 5)
623 #define NDIS_MAC_OPTION_8021P_PRIORITY (1 << 6)
625 struct rndis_response
{
626 QTAILQ_ENTRY(rndis_response
) entries
;
631 typedef struct USBNetState
{
634 enum rndis_state rndis_state
;
637 uint32_t media_state
;
641 unsigned int out_ptr
;
642 uint8_t out_buf
[2048];
644 unsigned int in_ptr
, in_len
;
645 uint8_t in_buf
[2048];
649 char usbstring_mac
[13];
652 QTAILQ_HEAD(, rndis_response
) rndis_resp
;
655 #define TYPE_USB_NET "usb-net"
656 #define USB_NET(obj) OBJECT_CHECK(USBNetState, (obj), TYPE_USB_NET)
658 static int is_rndis(USBNetState
*s
)
660 return s
->dev
.config
?
661 s
->dev
.config
->bConfigurationValue
== DEV_RNDIS_CONFIG_VALUE
: 0;
664 static int ndis_query(USBNetState
*s
, uint32_t oid
,
665 uint8_t *inbuf
, unsigned int inlen
, uint8_t *outbuf
,
671 /* general oids (table 4-1) */
673 case OID_GEN_SUPPORTED_LIST
:
674 for (i
= 0; i
< ARRAY_SIZE(oid_supported_list
); i
++) {
675 stl_le_p(outbuf
+ (i
* sizeof(le32
)), oid_supported_list
[i
]);
677 return sizeof(oid_supported_list
);
680 case OID_GEN_HARDWARE_STATUS
:
685 case OID_GEN_MEDIA_SUPPORTED
:
686 stl_le_p(outbuf
, s
->medium
);
690 case OID_GEN_MEDIA_IN_USE
:
691 stl_le_p(outbuf
, s
->medium
);
695 case OID_GEN_MAXIMUM_FRAME_SIZE
:
696 stl_le_p(outbuf
, ETH_FRAME_LEN
);
700 case OID_GEN_LINK_SPEED
:
701 stl_le_p(outbuf
, s
->speed
);
705 case OID_GEN_TRANSMIT_BLOCK_SIZE
:
706 stl_le_p(outbuf
, ETH_FRAME_LEN
);
710 case OID_GEN_RECEIVE_BLOCK_SIZE
:
711 stl_le_p(outbuf
, ETH_FRAME_LEN
);
715 case OID_GEN_VENDOR_ID
:
716 stl_le_p(outbuf
, s
->vendorid
);
720 case OID_GEN_VENDOR_DESCRIPTION
:
721 pstrcpy((char *)outbuf
, outlen
, "QEMU USB RNDIS Net");
722 return strlen((char *)outbuf
) + 1;
724 case OID_GEN_VENDOR_DRIVER_VERSION
:
729 case OID_GEN_CURRENT_PACKET_FILTER
:
730 stl_le_p(outbuf
, s
->filter
);
734 case OID_GEN_MAXIMUM_TOTAL_SIZE
:
735 stl_le_p(outbuf
, RNDIS_MAX_TOTAL_SIZE
);
739 case OID_GEN_MEDIA_CONNECT_STATUS
:
740 stl_le_p(outbuf
, s
->media_state
);
743 case OID_GEN_PHYSICAL_MEDIUM
:
747 case OID_GEN_MAC_OPTIONS
:
748 stl_le_p(outbuf
, NDIS_MAC_OPTION_RECEIVE_SERIALIZED
|
749 NDIS_MAC_OPTION_FULL_DUPLEX
);
752 /* statistics OIDs (table 4-2) */
754 case OID_GEN_XMIT_OK
:
764 case OID_GEN_XMIT_ERROR
:
769 case OID_GEN_RCV_ERROR
:
774 case OID_GEN_RCV_NO_BUFFER
:
778 /* ieee802.3 OIDs (table 4-3) */
780 case OID_802_3_PERMANENT_ADDRESS
:
781 memcpy(outbuf
, s
->conf
.macaddr
.a
, 6);
785 case OID_802_3_CURRENT_ADDRESS
:
786 memcpy(outbuf
, s
->conf
.macaddr
.a
, 6);
790 case OID_802_3_MULTICAST_LIST
:
791 stl_le_p(outbuf
, 0xe0000000);
795 case OID_802_3_MAXIMUM_LIST_SIZE
:
799 case OID_802_3_MAC_OPTIONS
:
802 /* ieee802.3 statistics OIDs (table 4-4) */
804 case OID_802_3_RCV_ERROR_ALIGNMENT
:
809 case OID_802_3_XMIT_ONE_COLLISION
:
814 case OID_802_3_XMIT_MORE_COLLISIONS
:
819 fprintf(stderr
, "usbnet: unknown OID 0x%08x\n", oid
);
825 static int ndis_set(USBNetState
*s
, uint32_t oid
,
826 uint8_t *inbuf
, unsigned int inlen
)
829 case OID_GEN_CURRENT_PACKET_FILTER
:
830 s
->filter
= ldl_le_p(inbuf
);
832 s
->rndis_state
= RNDIS_DATA_INITIALIZED
;
834 s
->rndis_state
= RNDIS_INITIALIZED
;
838 case OID_802_3_MULTICAST_LIST
:
844 static int rndis_get_response(USBNetState
*s
, uint8_t *buf
)
847 struct rndis_response
*r
= s
->rndis_resp
.tqh_first
;
852 QTAILQ_REMOVE(&s
->rndis_resp
, r
, entries
);
854 memcpy(buf
, r
->buf
, r
->length
);
860 static void *rndis_queue_response(USBNetState
*s
, unsigned int length
)
862 struct rndis_response
*r
=
863 g_malloc0(sizeof(struct rndis_response
) + length
);
865 if (QTAILQ_EMPTY(&s
->rndis_resp
)) {
866 usb_wakeup(s
->intr
, 0);
869 QTAILQ_INSERT_TAIL(&s
->rndis_resp
, r
, entries
);
875 static void rndis_clear_responsequeue(USBNetState
*s
)
877 struct rndis_response
*r
;
879 while ((r
= s
->rndis_resp
.tqh_first
)) {
880 QTAILQ_REMOVE(&s
->rndis_resp
, r
, entries
);
885 static int rndis_init_response(USBNetState
*s
, rndis_init_msg_type
*buf
)
887 rndis_init_cmplt_type
*resp
=
888 rndis_queue_response(s
, sizeof(rndis_init_cmplt_type
));
891 return USB_RET_STALL
;
893 resp
->MessageType
= cpu_to_le32(RNDIS_INITIALIZE_CMPLT
);
894 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_init_cmplt_type
));
895 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
896 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
897 resp
->MajorVersion
= cpu_to_le32(RNDIS_MAJOR_VERSION
);
898 resp
->MinorVersion
= cpu_to_le32(RNDIS_MINOR_VERSION
);
899 resp
->DeviceFlags
= cpu_to_le32(RNDIS_DF_CONNECTIONLESS
);
900 resp
->Medium
= cpu_to_le32(RNDIS_MEDIUM_802_3
);
901 resp
->MaxPacketsPerTransfer
= cpu_to_le32(1);
902 resp
->MaxTransferSize
= cpu_to_le32(ETH_FRAME_LEN
+
903 sizeof(struct rndis_packet_msg_type
) + 22);
904 resp
->PacketAlignmentFactor
= cpu_to_le32(0);
905 resp
->AFListOffset
= cpu_to_le32(0);
906 resp
->AFListSize
= cpu_to_le32(0);
910 static int rndis_query_response(USBNetState
*s
,
911 rndis_query_msg_type
*buf
, unsigned int length
)
913 rndis_query_cmplt_type
*resp
;
914 /* oid_supported_list is the largest data reply */
915 uint8_t infobuf
[sizeof(oid_supported_list
)];
916 uint32_t bufoffs
, buflen
;
918 unsigned int resplen
;
920 bufoffs
= le32_to_cpu(buf
->InformationBufferOffset
) + 8;
921 buflen
= le32_to_cpu(buf
->InformationBufferLength
);
922 if (buflen
> length
|| bufoffs
>= length
|| bufoffs
+ buflen
> length
) {
923 return USB_RET_STALL
;
926 infobuflen
= ndis_query(s
, le32_to_cpu(buf
->OID
),
927 bufoffs
+ (uint8_t *) buf
, buflen
, infobuf
,
929 resplen
= sizeof(rndis_query_cmplt_type
) +
930 ((infobuflen
< 0) ? 0 : infobuflen
);
931 resp
= rndis_queue_response(s
, resplen
);
933 return USB_RET_STALL
;
935 resp
->MessageType
= cpu_to_le32(RNDIS_QUERY_CMPLT
);
936 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
937 resp
->MessageLength
= cpu_to_le32(resplen
);
939 if (infobuflen
< 0) {
940 /* OID not supported */
941 resp
->Status
= cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED
);
942 resp
->InformationBufferLength
= cpu_to_le32(0);
943 resp
->InformationBufferOffset
= cpu_to_le32(0);
947 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
948 resp
->InformationBufferOffset
=
949 cpu_to_le32(infobuflen
? sizeof(rndis_query_cmplt_type
) - 8 : 0);
950 resp
->InformationBufferLength
= cpu_to_le32(infobuflen
);
951 memcpy(resp
+ 1, infobuf
, infobuflen
);
956 static int rndis_set_response(USBNetState
*s
,
957 rndis_set_msg_type
*buf
, unsigned int length
)
959 rndis_set_cmplt_type
*resp
=
960 rndis_queue_response(s
, sizeof(rndis_set_cmplt_type
));
961 uint32_t bufoffs
, buflen
;
965 return USB_RET_STALL
;
967 bufoffs
= le32_to_cpu(buf
->InformationBufferOffset
) + 8;
968 buflen
= le32_to_cpu(buf
->InformationBufferLength
);
969 if (buflen
> length
|| bufoffs
>= length
|| bufoffs
+ buflen
> length
) {
970 return USB_RET_STALL
;
973 ret
= ndis_set(s
, le32_to_cpu(buf
->OID
),
974 bufoffs
+ (uint8_t *) buf
, buflen
);
975 resp
->MessageType
= cpu_to_le32(RNDIS_SET_CMPLT
);
976 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
977 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_set_cmplt_type
));
979 /* OID not supported */
980 resp
->Status
= cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED
);
983 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
988 static int rndis_reset_response(USBNetState
*s
, rndis_reset_msg_type
*buf
)
990 rndis_reset_cmplt_type
*resp
=
991 rndis_queue_response(s
, sizeof(rndis_reset_cmplt_type
));
994 return USB_RET_STALL
;
996 resp
->MessageType
= cpu_to_le32(RNDIS_RESET_CMPLT
);
997 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_reset_cmplt_type
));
998 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
999 resp
->AddressingReset
= cpu_to_le32(1); /* reset information */
1004 static int rndis_keepalive_response(USBNetState
*s
,
1005 rndis_keepalive_msg_type
*buf
)
1007 rndis_keepalive_cmplt_type
*resp
=
1008 rndis_queue_response(s
, sizeof(rndis_keepalive_cmplt_type
));
1011 return USB_RET_STALL
;
1013 resp
->MessageType
= cpu_to_le32(RNDIS_KEEPALIVE_CMPLT
);
1014 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_keepalive_cmplt_type
));
1015 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
1016 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
1021 /* Prepare to receive the next packet */
1022 static void usb_net_reset_in_buf(USBNetState
*s
)
1024 s
->in_ptr
= s
->in_len
= 0;
1025 qemu_flush_queued_packets(qemu_get_queue(s
->nic
));
1028 static int rndis_parse(USBNetState
*s
, uint8_t *data
, int length
)
1030 uint32_t msg_type
= ldl_le_p(data
);
1033 case RNDIS_INITIALIZE_MSG
:
1034 s
->rndis_state
= RNDIS_INITIALIZED
;
1035 return rndis_init_response(s
, (rndis_init_msg_type
*) data
);
1037 case RNDIS_HALT_MSG
:
1038 s
->rndis_state
= RNDIS_UNINITIALIZED
;
1041 case RNDIS_QUERY_MSG
:
1042 return rndis_query_response(s
, (rndis_query_msg_type
*) data
, length
);
1045 return rndis_set_response(s
, (rndis_set_msg_type
*) data
, length
);
1047 case RNDIS_RESET_MSG
:
1048 rndis_clear_responsequeue(s
);
1050 usb_net_reset_in_buf(s
);
1051 return rndis_reset_response(s
, (rndis_reset_msg_type
*) data
);
1053 case RNDIS_KEEPALIVE_MSG
:
1054 /* For USB: host does this every 5 seconds */
1055 return rndis_keepalive_response(s
, (rndis_keepalive_msg_type
*) data
);
1058 return USB_RET_STALL
;
1061 static void usb_net_handle_reset(USBDevice
*dev
)
1065 static void usb_net_handle_control(USBDevice
*dev
, USBPacket
*p
,
1066 int request
, int value
, int index
, int length
, uint8_t *data
)
1068 USBNetState
*s
= (USBNetState
*) dev
;
1071 ret
= usb_desc_handle_control(dev
, p
, request
, value
, index
, length
, data
);
1077 case ClassInterfaceOutRequest
| USB_CDC_SEND_ENCAPSULATED_COMMAND
:
1078 if (!is_rndis(s
) || value
|| index
!= 0) {
1081 #ifdef TRAFFIC_DEBUG
1084 fprintf(stderr
, "SEND_ENCAPSULATED_COMMAND:");
1085 for (i
= 0; i
< length
; i
++) {
1087 fprintf(stderr
, "\n%04x:", i
);
1088 fprintf(stderr
, " %02x", data
[i
]);
1090 fprintf(stderr
, "\n\n");
1093 ret
= rndis_parse(s
, data
, length
);
1099 case ClassInterfaceRequest
| USB_CDC_GET_ENCAPSULATED_RESPONSE
:
1100 if (!is_rndis(s
) || value
|| index
!= 0) {
1103 p
->actual_length
= rndis_get_response(s
, data
);
1104 if (p
->actual_length
== 0) {
1106 p
->actual_length
= 1;
1108 #ifdef TRAFFIC_DEBUG
1111 fprintf(stderr
, "GET_ENCAPSULATED_RESPONSE:");
1112 for (i
= 0; i
< p
->actual_length
; i
++) {
1114 fprintf(stderr
, "\n%04x:", i
);
1115 fprintf(stderr
, " %02x", data
[i
]);
1117 fprintf(stderr
, "\n\n");
1124 fprintf(stderr
, "usbnet: failed control transaction: "
1125 "request 0x%x value 0x%x index 0x%x length 0x%x\n",
1126 request
, value
, index
, length
);
1127 p
->status
= USB_RET_STALL
;
1132 static void usb_net_handle_statusin(USBNetState
*s
, USBPacket
*p
)
1136 if (p
->iov
.size
< 8) {
1137 p
->status
= USB_RET_STALL
;
1141 buf
[0] = cpu_to_le32(1);
1142 buf
[1] = cpu_to_le32(0);
1143 usb_packet_copy(p
, buf
, 8);
1144 if (!s
->rndis_resp
.tqh_first
) {
1145 p
->status
= USB_RET_NAK
;
1148 #ifdef TRAFFIC_DEBUG
1149 fprintf(stderr
, "usbnet: interrupt poll len %zu return %d",
1150 p
->iov
.size
, p
->status
);
1151 iov_hexdump(p
->iov
.iov
, p
->iov
.niov
, stderr
, "usbnet", p
->status
);
1155 static void usb_net_handle_datain(USBNetState
*s
, USBPacket
*p
)
1159 if (s
->in_ptr
> s
->in_len
) {
1160 usb_net_reset_in_buf(s
);
1161 p
->status
= USB_RET_NAK
;
1165 p
->status
= USB_RET_NAK
;
1168 len
= s
->in_len
- s
->in_ptr
;
1169 if (len
> p
->iov
.size
) {
1172 usb_packet_copy(p
, &s
->in_buf
[s
->in_ptr
], len
);
1174 if (s
->in_ptr
>= s
->in_len
&&
1175 (is_rndis(s
) || (s
->in_len
& (64 - 1)) || !len
)) {
1176 /* no short packet necessary */
1177 usb_net_reset_in_buf(s
);
1180 #ifdef TRAFFIC_DEBUG
1181 fprintf(stderr
, "usbnet: data in len %zu return %d", p
->iov
.size
, len
);
1182 iov_hexdump(p
->iov
.iov
, p
->iov
.niov
, stderr
, "usbnet", len
);
1186 static void usb_net_handle_dataout(USBNetState
*s
, USBPacket
*p
)
1188 int sz
= sizeof(s
->out_buf
) - s
->out_ptr
;
1189 struct rndis_packet_msg_type
*msg
=
1190 (struct rndis_packet_msg_type
*) s
->out_buf
;
1193 #ifdef TRAFFIC_DEBUG
1194 fprintf(stderr
, "usbnet: data out len %zu\n", p
->iov
.size
);
1195 iov_hexdump(p
->iov
.iov
, p
->iov
.niov
, stderr
, "usbnet", p
->iov
.size
);
1198 if (sz
> p
->iov
.size
) {
1201 usb_packet_copy(p
, &s
->out_buf
[s
->out_ptr
], sz
);
1205 if (p
->iov
.size
< 64) {
1206 qemu_send_packet(qemu_get_queue(s
->nic
), s
->out_buf
, s
->out_ptr
);
1211 len
= le32_to_cpu(msg
->MessageLength
);
1212 if (s
->out_ptr
< 8 || s
->out_ptr
< len
) {
1215 if (le32_to_cpu(msg
->MessageType
) == RNDIS_PACKET_MSG
) {
1216 uint32_t offs
= 8 + le32_to_cpu(msg
->DataOffset
);
1217 uint32_t size
= le32_to_cpu(msg
->DataLength
);
1218 if (offs
< len
&& size
< len
&& offs
+ size
<= len
) {
1219 qemu_send_packet(qemu_get_queue(s
->nic
), s
->out_buf
+ offs
, size
);
1223 memmove(s
->out_buf
, &s
->out_buf
[len
], s
->out_ptr
);
1226 static void usb_net_handle_data(USBDevice
*dev
, USBPacket
*p
)
1228 USBNetState
*s
= (USBNetState
*) dev
;
1232 switch (p
->ep
->nr
) {
1234 usb_net_handle_statusin(s
, p
);
1238 usb_net_handle_datain(s
, p
);
1247 switch (p
->ep
->nr
) {
1249 usb_net_handle_dataout(s
, p
);
1259 p
->status
= USB_RET_STALL
;
1263 if (p
->status
== USB_RET_STALL
) {
1264 fprintf(stderr
, "usbnet: failed data transaction: "
1265 "pid 0x%x ep 0x%x len 0x%zx\n",
1266 p
->pid
, p
->ep
->nr
, p
->iov
.size
);
1270 static ssize_t
usbnet_receive(NetClientState
*nc
, const uint8_t *buf
, size_t size
)
1272 USBNetState
*s
= qemu_get_nic_opaque(nc
);
1273 uint8_t *in_buf
= s
->in_buf
;
1274 size_t total_size
= size
;
1276 if (!s
->dev
.config
) {
1281 if (s
->rndis_state
!= RNDIS_DATA_INITIALIZED
) {
1284 total_size
+= sizeof(struct rndis_packet_msg_type
);
1286 if (total_size
> sizeof(s
->in_buf
)) {
1290 /* Only accept packet if input buffer is empty */
1291 if (s
->in_len
> 0) {
1296 struct rndis_packet_msg_type
*msg
;
1298 msg
= (struct rndis_packet_msg_type
*)in_buf
;
1299 memset(msg
, 0, sizeof(struct rndis_packet_msg_type
));
1300 msg
->MessageType
= cpu_to_le32(RNDIS_PACKET_MSG
);
1301 msg
->MessageLength
= cpu_to_le32(size
+ sizeof(*msg
));
1302 msg
->DataOffset
= cpu_to_le32(sizeof(*msg
) - 8);
1303 msg
->DataLength
= cpu_to_le32(size
);
1304 /* msg->OOBDataOffset;
1305 * msg->OOBDataLength;
1306 * msg->NumOOBDataElements;
1307 * msg->PerPacketInfoOffset;
1308 * msg->PerPacketInfoLength;
1312 in_buf
+= sizeof(*msg
);
1315 memcpy(in_buf
, buf
, size
);
1316 s
->in_len
= total_size
;
1321 static void usbnet_cleanup(NetClientState
*nc
)
1323 USBNetState
*s
= qemu_get_nic_opaque(nc
);
1328 static void usb_net_unrealize(USBDevice
*dev
, Error
**errp
)
1330 USBNetState
*s
= (USBNetState
*) dev
;
1332 /* TODO: remove the nd_table[] entry */
1333 rndis_clear_responsequeue(s
);
1334 qemu_del_nic(s
->nic
);
1337 static NetClientInfo net_usbnet_info
= {
1338 .type
= NET_CLIENT_DRIVER_NIC
,
1339 .size
= sizeof(NICState
),
1340 .receive
= usbnet_receive
,
1341 .cleanup
= usbnet_cleanup
,
1344 static void usb_net_realize(USBDevice
*dev
, Error
**errrp
)
1346 USBNetState
*s
= USB_NET(dev
);
1348 usb_desc_create_serial(dev
);
1351 s
->rndis_state
= RNDIS_UNINITIALIZED
;
1352 QTAILQ_INIT(&s
->rndis_resp
);
1354 s
->medium
= 0; /* NDIS_MEDIUM_802_3 */
1355 s
->speed
= 1000000; /* 100MBps, in 100Bps units */
1356 s
->media_state
= 0; /* NDIS_MEDIA_STATE_CONNECTED */;
1358 s
->vendorid
= 0x1234;
1359 s
->intr
= usb_ep_get(dev
, USB_TOKEN_IN
, 1);
1361 qemu_macaddr_default_if_unset(&s
->conf
.macaddr
);
1362 s
->nic
= qemu_new_nic(&net_usbnet_info
, &s
->conf
,
1363 object_get_typename(OBJECT(s
)), s
->dev
.qdev
.id
, s
);
1364 qemu_format_nic_info_str(qemu_get_queue(s
->nic
), s
->conf
.macaddr
.a
);
1365 snprintf(s
->usbstring_mac
, sizeof(s
->usbstring_mac
),
1366 "%02x%02x%02x%02x%02x%02x",
1368 s
->conf
.macaddr
.a
[1],
1369 s
->conf
.macaddr
.a
[2],
1370 s
->conf
.macaddr
.a
[3],
1371 s
->conf
.macaddr
.a
[4],
1372 s
->conf
.macaddr
.a
[5]);
1373 usb_desc_set_string(dev
, STRING_ETHADDR
, s
->usbstring_mac
);
1376 static void usb_net_instance_init(Object
*obj
)
1378 USBDevice
*dev
= USB_DEVICE(obj
);
1379 USBNetState
*s
= USB_NET(dev
);
1381 device_add_bootindex_property(obj
, &s
->conf
.bootindex
,
1382 "bootindex", "/ethernet-phy@0",
1386 static const VMStateDescription vmstate_usb_net
= {
1391 static Property net_properties
[] = {
1392 DEFINE_NIC_PROPERTIES(USBNetState
, conf
),
1393 DEFINE_PROP_END_OF_LIST(),
1396 static void usb_net_class_initfn(ObjectClass
*klass
, void *data
)
1398 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1399 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
1401 uc
->realize
= usb_net_realize
;
1402 uc
->product_desc
= "QEMU USB Network Interface";
1403 uc
->usb_desc
= &desc_net
;
1404 uc
->handle_reset
= usb_net_handle_reset
;
1405 uc
->handle_control
= usb_net_handle_control
;
1406 uc
->handle_data
= usb_net_handle_data
;
1407 uc
->unrealize
= usb_net_unrealize
;
1408 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1409 dc
->fw_name
= "network";
1410 dc
->vmsd
= &vmstate_usb_net
;
1411 dc
->props
= net_properties
;
1414 static const TypeInfo net_info
= {
1415 .name
= TYPE_USB_NET
,
1416 .parent
= TYPE_USB_DEVICE
,
1417 .instance_size
= sizeof(USBNetState
),
1418 .class_init
= usb_net_class_initfn
,
1419 .instance_init
= usb_net_instance_init
,
1422 static void usb_net_register_types(void)
1424 type_register_static(&net_info
);
1427 type_init(usb_net_register_types
)