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"
28 #include "hw/qdev-properties.h"
30 #include "migration/vmstate.h"
33 #include "qemu/error-report.h"
34 #include "qemu/queue.h"
35 #include "qemu/config-file.h"
36 #include "sysemu/sysemu.h"
38 #include "qemu/module.h"
39 #include "qemu/cutils.h"
40 #include "qom/object.h"
42 /*#define TRAFFIC_DEBUG*/
43 /* Thanks to NetChip Technologies for donating this product ID.
44 * It's for devices with only CDC Ethernet configurations.
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.
51 #define RNDIS_VENDOR_NUM 0x0525 /* NetChip */
52 #define RNDIS_PRODUCT_NUM 0xa4a2 /* Ethernet/RNDIS Gadget */
55 STRING_MANUFACTURER
= 1,
67 #define DEV_CONFIG_VALUE 1 /* CDC or a subset */
68 #define DEV_RNDIS_CONFIG_VALUE 2 /* RNDIS; optional */
70 #define USB_CDC_SUBCLASS_ACM 0x02
71 #define USB_CDC_SUBCLASS_ETHERNET 0x06
73 #define USB_CDC_PROTO_NONE 0
74 #define USB_CDC_ACM_PROTO_VENDOR 0xff
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 */
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
94 #define LOG2_STATUS_INTERVAL_MSEC 5 /* 1 << 5 == 32 msec */
95 #define STATUS_BYTECOUNT 16 /* 8 byte header + data */
97 #define ETH_FRAME_LEN 1514 /* Max. octets in frame sans FCS */
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",
112 static const USBDescIface desc_iface_rndis
[] = {
114 /* RNDIS Control Interface */
115 .bInterfaceNumber
= 0,
117 .bInterfaceClass
= USB_CLASS_COMM
,
118 .bInterfaceSubClass
= USB_CDC_SUBCLASS_ACM
,
119 .bInterfaceProtocol
= USB_CDC_ACM_PROTO_VENDOR
,
120 .iInterface
= STRING_RNDIS_CONTROL
,
122 .descs
= (USBDescOther
[]) {
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 */
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 */
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 */
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 */
159 .eps
= (USBDescEndpoint
[]) {
161 .bEndpointAddress
= USB_DIR_IN
| 0x01,
162 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
163 .wMaxPacketSize
= STATUS_BYTECOUNT
,
164 .bInterval
= 1 << LOG2_STATUS_INTERVAL_MSEC
,
168 /* RNDIS Data Interface */
169 .bInterfaceNumber
= 1,
171 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
172 .iInterface
= STRING_DATA
,
173 .eps
= (USBDescEndpoint
[]) {
175 .bEndpointAddress
= USB_DIR_IN
| 0x02,
176 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
177 .wMaxPacketSize
= 0x40,
179 .bEndpointAddress
= USB_DIR_OUT
| 0x02,
180 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
181 .wMaxPacketSize
= 0x40,
187 static const USBDescIface desc_iface_cdc
[] = {
189 /* CDC Control Interface */
190 .bInterfaceNumber
= 0,
192 .bInterfaceClass
= USB_CLASS_COMM
,
193 .bInterfaceSubClass
= USB_CDC_SUBCLASS_ETHERNET
,
194 .bInterfaceProtocol
= USB_CDC_PROTO_NONE
,
195 .iInterface
= STRING_CONTROL
,
197 .descs
= (USBDescOther
[]) {
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 */
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 */
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 */
230 .eps
= (USBDescEndpoint
[]) {
232 .bEndpointAddress
= USB_DIR_IN
| 0x01,
233 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
234 .wMaxPacketSize
= STATUS_BYTECOUNT
,
235 .bInterval
= 1 << LOG2_STATUS_INTERVAL_MSEC
,
239 /* CDC Data Interface (off) */
240 .bInterfaceNumber
= 1,
241 .bAlternateSetting
= 0,
243 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
245 /* CDC Data Interface */
246 .bInterfaceNumber
= 1,
247 .bAlternateSetting
= 1,
249 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
250 .iInterface
= STRING_DATA
,
251 .eps
= (USBDescEndpoint
[]) {
253 .bEndpointAddress
= USB_DIR_IN
| 0x02,
254 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
255 .wMaxPacketSize
= 0x40,
257 .bEndpointAddress
= USB_DIR_OUT
| 0x02,
258 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
259 .wMaxPacketSize
= 0x40,
265 static const USBDescDevice desc_device_net
= {
267 .bDeviceClass
= USB_CLASS_COMM
,
268 .bMaxPacketSize0
= 0x40,
269 .bNumConfigurations
= 2,
270 .confs
= (USBDescConfig
[]) {
273 .bConfigurationValue
= DEV_RNDIS_CONFIG_VALUE
,
274 .iConfiguration
= STRING_RNDIS
,
275 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_SELFPOWER
,
277 .nif
= ARRAY_SIZE(desc_iface_rndis
),
278 .ifs
= desc_iface_rndis
,
281 .bConfigurationValue
= DEV_CONFIG_VALUE
,
282 .iConfiguration
= STRING_CDC
,
283 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_SELFPOWER
,
285 .nif
= ARRAY_SIZE(desc_iface_cdc
),
286 .ifs
= desc_iface_cdc
,
291 static const USBDesc desc_net
= {
293 .idVendor
= RNDIS_VENDOR_NUM
,
294 .idProduct
= RNDIS_PRODUCT_NUM
,
296 .iManufacturer
= STRING_MANUFACTURER
,
297 .iProduct
= STRING_PRODUCT
,
298 .iSerialNumber
= STRING_SERIALNUMBER
,
300 .full
= &desc_device_net
,
301 .str
= usb_net_stringtable
,
305 * RNDIS Definitions - in theory not specific to USB.
307 #define RNDIS_MAXIMUM_FRAME_SIZE 1518
308 #define RNDIS_MAX_TOTAL_SIZE 1558
310 /* Remote NDIS Versions */
311 #define RNDIS_MAJOR_VERSION 1
312 #define RNDIS_MINOR_VERSION 0
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 */
322 /* Message Set for Connectionless (802.3) Devices */
324 RNDIS_PACKET_MSG
= 1,
325 RNDIS_INITIALIZE_MSG
= 2, /* Initialize device */
330 RNDIS_INDICATE_STATUS_MSG
= 7,
331 RNDIS_KEEPALIVE_MSG
= 8,
334 /* Message completion */
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
,
345 RNDIS_DF_CONNECTIONLESS
= 1,
346 RNDIS_DF_CONNECTIONORIENTED
= 2,
349 #define RNDIS_MEDIUM_802_3 0x00000000U
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
359 typedef uint32_t le32
;
361 typedef struct rndis_init_msg_type
{
367 le32 MaxTransferSize
;
368 } rndis_init_msg_type
;
370 typedef struct rndis_init_cmplt_type
{
379 le32 MaxPacketsPerTransfer
;
380 le32 MaxTransferSize
;
381 le32 PacketAlignmentFactor
;
384 } rndis_init_cmplt_type
;
386 typedef struct rndis_halt_msg_type
{
390 } rndis_halt_msg_type
;
392 typedef struct rndis_query_msg_type
{
397 le32 InformationBufferLength
;
398 le32 InformationBufferOffset
;
400 } rndis_query_msg_type
;
402 typedef struct rndis_query_cmplt_type
{
407 le32 InformationBufferLength
;
408 le32 InformationBufferOffset
;
409 } rndis_query_cmplt_type
;
411 typedef struct rndis_set_msg_type
{
416 le32 InformationBufferLength
;
417 le32 InformationBufferOffset
;
419 } rndis_set_msg_type
;
421 typedef struct rndis_set_cmplt_type
{
426 } rndis_set_cmplt_type
;
428 typedef struct rndis_reset_msg_type
{
432 } rndis_reset_msg_type
;
434 typedef struct rndis_reset_cmplt_type
{
438 le32 AddressingReset
;
439 } rndis_reset_cmplt_type
;
441 typedef struct rndis_indicate_status_msg_type
{
445 le32 StatusBufferLength
;
446 le32 StatusBufferOffset
;
447 } rndis_indicate_status_msg_type
;
449 typedef struct rndis_keepalive_msg_type
{
453 } rndis_keepalive_msg_type
;
455 typedef struct rndis_keepalive_cmplt_type
{
460 } rndis_keepalive_cmplt_type
;
462 struct rndis_packet_msg_type
{
469 le32 NumOOBDataElements
;
470 le32 PerPacketInfoOffset
;
471 le32 PerPacketInfoLength
;
476 struct rndis_config_parameter
{
477 le32 ParameterNameOffset
;
478 le32 ParameterNameLength
;
480 le32 ParameterValueOffset
;
481 le32 ParameterValueLength
;
484 /* implementation specific */
489 RNDIS_DATA_INITIALIZED
,
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,
525 OID_GEN_MEDIA_CAPABILITIES
= 0x00010201,
526 OID_GEN_PHYSICAL_MEDIUM
= 0x00010202,
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,
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,
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,
579 static const uint32_t oid_supported_list
[] =
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
,
588 OID_GEN_TRANSMIT_BLOCK_SIZE
,
589 OID_GEN_RECEIVE_BLOCK_SIZE
,
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
,
598 /* the statistical stuff */
603 OID_GEN_RCV_NO_BUFFER
,
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
,
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
,
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)
627 struct rndis_response
{
628 QTAILQ_ENTRY(rndis_response
) entries
;
636 enum rndis_state rndis_state
;
639 uint32_t media_state
;
643 unsigned int out_ptr
;
644 uint8_t out_buf
[2048];
646 unsigned int in_ptr
, in_len
;
647 uint8_t in_buf
[2048];
651 char usbstring_mac
[13];
654 QTAILQ_HEAD(, rndis_response
) rndis_resp
;
656 typedef struct USBNetState USBNetState
;
658 #define TYPE_USB_NET "usb-net"
659 #define USB_NET(obj) OBJECT_CHECK(USBNetState, (obj), TYPE_USB_NET)
661 static int is_rndis(USBNetState
*s
)
663 return s
->dev
.config
?
664 s
->dev
.config
->bConfigurationValue
== DEV_RNDIS_CONFIG_VALUE
: 0;
667 static int ndis_query(USBNetState
*s
, uint32_t oid
,
668 uint8_t *inbuf
, unsigned int inlen
, uint8_t *outbuf
,
674 /* general oids (table 4-1) */
676 case OID_GEN_SUPPORTED_LIST
:
677 for (i
= 0; i
< ARRAY_SIZE(oid_supported_list
); i
++) {
678 stl_le_p(outbuf
+ (i
* sizeof(le32
)), oid_supported_list
[i
]);
680 return sizeof(oid_supported_list
);
683 case OID_GEN_HARDWARE_STATUS
:
688 case OID_GEN_MEDIA_SUPPORTED
:
689 stl_le_p(outbuf
, s
->medium
);
693 case OID_GEN_MEDIA_IN_USE
:
694 stl_le_p(outbuf
, s
->medium
);
698 case OID_GEN_MAXIMUM_FRAME_SIZE
:
699 stl_le_p(outbuf
, ETH_FRAME_LEN
);
703 case OID_GEN_LINK_SPEED
:
704 stl_le_p(outbuf
, s
->speed
);
708 case OID_GEN_TRANSMIT_BLOCK_SIZE
:
709 stl_le_p(outbuf
, ETH_FRAME_LEN
);
713 case OID_GEN_RECEIVE_BLOCK_SIZE
:
714 stl_le_p(outbuf
, ETH_FRAME_LEN
);
718 case OID_GEN_VENDOR_ID
:
719 stl_le_p(outbuf
, s
->vendorid
);
723 case OID_GEN_VENDOR_DESCRIPTION
:
724 pstrcpy((char *)outbuf
, outlen
, "QEMU USB RNDIS Net");
725 return strlen((char *)outbuf
) + 1;
727 case OID_GEN_VENDOR_DRIVER_VERSION
:
732 case OID_GEN_CURRENT_PACKET_FILTER
:
733 stl_le_p(outbuf
, s
->filter
);
737 case OID_GEN_MAXIMUM_TOTAL_SIZE
:
738 stl_le_p(outbuf
, RNDIS_MAX_TOTAL_SIZE
);
742 case OID_GEN_MEDIA_CONNECT_STATUS
:
743 stl_le_p(outbuf
, s
->media_state
);
746 case OID_GEN_PHYSICAL_MEDIUM
:
750 case OID_GEN_MAC_OPTIONS
:
751 stl_le_p(outbuf
, NDIS_MAC_OPTION_RECEIVE_SERIALIZED
|
752 NDIS_MAC_OPTION_FULL_DUPLEX
);
755 /* statistics OIDs (table 4-2) */
757 case OID_GEN_XMIT_OK
:
767 case OID_GEN_XMIT_ERROR
:
772 case OID_GEN_RCV_ERROR
:
777 case OID_GEN_RCV_NO_BUFFER
:
781 /* ieee802.3 OIDs (table 4-3) */
783 case OID_802_3_PERMANENT_ADDRESS
:
784 memcpy(outbuf
, s
->conf
.macaddr
.a
, 6);
788 case OID_802_3_CURRENT_ADDRESS
:
789 memcpy(outbuf
, s
->conf
.macaddr
.a
, 6);
793 case OID_802_3_MULTICAST_LIST
:
794 stl_le_p(outbuf
, 0xe0000000);
798 case OID_802_3_MAXIMUM_LIST_SIZE
:
802 case OID_802_3_MAC_OPTIONS
:
805 /* ieee802.3 statistics OIDs (table 4-4) */
807 case OID_802_3_RCV_ERROR_ALIGNMENT
:
812 case OID_802_3_XMIT_ONE_COLLISION
:
817 case OID_802_3_XMIT_MORE_COLLISIONS
:
822 fprintf(stderr
, "usbnet: unknown OID 0x%08x\n", oid
);
828 static int ndis_set(USBNetState
*s
, uint32_t oid
,
829 uint8_t *inbuf
, unsigned int inlen
)
832 case OID_GEN_CURRENT_PACKET_FILTER
:
833 s
->filter
= ldl_le_p(inbuf
);
835 s
->rndis_state
= RNDIS_DATA_INITIALIZED
;
837 s
->rndis_state
= RNDIS_INITIALIZED
;
841 case OID_802_3_MULTICAST_LIST
:
847 static int rndis_get_response(USBNetState
*s
, uint8_t *buf
)
850 struct rndis_response
*r
= s
->rndis_resp
.tqh_first
;
855 QTAILQ_REMOVE(&s
->rndis_resp
, r
, entries
);
857 memcpy(buf
, r
->buf
, r
->length
);
863 static void *rndis_queue_response(USBNetState
*s
, unsigned int length
)
865 struct rndis_response
*r
=
866 g_malloc0(sizeof(struct rndis_response
) + length
);
868 if (QTAILQ_EMPTY(&s
->rndis_resp
)) {
869 usb_wakeup(s
->intr
, 0);
872 QTAILQ_INSERT_TAIL(&s
->rndis_resp
, r
, entries
);
878 static void rndis_clear_responsequeue(USBNetState
*s
)
880 struct rndis_response
*r
;
882 while ((r
= s
->rndis_resp
.tqh_first
)) {
883 QTAILQ_REMOVE(&s
->rndis_resp
, r
, entries
);
888 static int rndis_init_response(USBNetState
*s
, rndis_init_msg_type
*buf
)
890 rndis_init_cmplt_type
*resp
=
891 rndis_queue_response(s
, sizeof(rndis_init_cmplt_type
));
894 return USB_RET_STALL
;
896 resp
->MessageType
= cpu_to_le32(RNDIS_INITIALIZE_CMPLT
);
897 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_init_cmplt_type
));
898 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
899 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
900 resp
->MajorVersion
= cpu_to_le32(RNDIS_MAJOR_VERSION
);
901 resp
->MinorVersion
= cpu_to_le32(RNDIS_MINOR_VERSION
);
902 resp
->DeviceFlags
= cpu_to_le32(RNDIS_DF_CONNECTIONLESS
);
903 resp
->Medium
= cpu_to_le32(RNDIS_MEDIUM_802_3
);
904 resp
->MaxPacketsPerTransfer
= cpu_to_le32(1);
905 resp
->MaxTransferSize
= cpu_to_le32(ETH_FRAME_LEN
+
906 sizeof(struct rndis_packet_msg_type
) + 22);
907 resp
->PacketAlignmentFactor
= cpu_to_le32(0);
908 resp
->AFListOffset
= cpu_to_le32(0);
909 resp
->AFListSize
= cpu_to_le32(0);
913 static int rndis_query_response(USBNetState
*s
,
914 rndis_query_msg_type
*buf
, unsigned int length
)
916 rndis_query_cmplt_type
*resp
;
917 /* oid_supported_list is the largest data reply */
918 uint8_t infobuf
[sizeof(oid_supported_list
)];
919 uint32_t bufoffs
, buflen
;
921 unsigned int resplen
;
923 bufoffs
= le32_to_cpu(buf
->InformationBufferOffset
) + 8;
924 buflen
= le32_to_cpu(buf
->InformationBufferLength
);
925 if (buflen
> length
|| bufoffs
>= length
|| bufoffs
+ buflen
> length
) {
926 return USB_RET_STALL
;
929 infobuflen
= ndis_query(s
, le32_to_cpu(buf
->OID
),
930 bufoffs
+ (uint8_t *) buf
, buflen
, infobuf
,
932 resplen
= sizeof(rndis_query_cmplt_type
) +
933 ((infobuflen
< 0) ? 0 : infobuflen
);
934 resp
= rndis_queue_response(s
, resplen
);
936 return USB_RET_STALL
;
938 resp
->MessageType
= cpu_to_le32(RNDIS_QUERY_CMPLT
);
939 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
940 resp
->MessageLength
= cpu_to_le32(resplen
);
942 if (infobuflen
< 0) {
943 /* OID not supported */
944 resp
->Status
= cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED
);
945 resp
->InformationBufferLength
= cpu_to_le32(0);
946 resp
->InformationBufferOffset
= cpu_to_le32(0);
950 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
951 resp
->InformationBufferOffset
=
952 cpu_to_le32(infobuflen
? sizeof(rndis_query_cmplt_type
) - 8 : 0);
953 resp
->InformationBufferLength
= cpu_to_le32(infobuflen
);
954 memcpy(resp
+ 1, infobuf
, infobuflen
);
959 static int rndis_set_response(USBNetState
*s
,
960 rndis_set_msg_type
*buf
, unsigned int length
)
962 rndis_set_cmplt_type
*resp
=
963 rndis_queue_response(s
, sizeof(rndis_set_cmplt_type
));
964 uint32_t bufoffs
, buflen
;
968 return USB_RET_STALL
;
970 bufoffs
= le32_to_cpu(buf
->InformationBufferOffset
) + 8;
971 buflen
= le32_to_cpu(buf
->InformationBufferLength
);
972 if (buflen
> length
|| bufoffs
>= length
|| bufoffs
+ buflen
> length
) {
973 return USB_RET_STALL
;
976 ret
= ndis_set(s
, le32_to_cpu(buf
->OID
),
977 bufoffs
+ (uint8_t *) buf
, buflen
);
978 resp
->MessageType
= cpu_to_le32(RNDIS_SET_CMPLT
);
979 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
980 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_set_cmplt_type
));
982 /* OID not supported */
983 resp
->Status
= cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED
);
986 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
991 static int rndis_reset_response(USBNetState
*s
, rndis_reset_msg_type
*buf
)
993 rndis_reset_cmplt_type
*resp
=
994 rndis_queue_response(s
, sizeof(rndis_reset_cmplt_type
));
997 return USB_RET_STALL
;
999 resp
->MessageType
= cpu_to_le32(RNDIS_RESET_CMPLT
);
1000 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_reset_cmplt_type
));
1001 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
1002 resp
->AddressingReset
= cpu_to_le32(1); /* reset information */
1007 static int rndis_keepalive_response(USBNetState
*s
,
1008 rndis_keepalive_msg_type
*buf
)
1010 rndis_keepalive_cmplt_type
*resp
=
1011 rndis_queue_response(s
, sizeof(rndis_keepalive_cmplt_type
));
1014 return USB_RET_STALL
;
1016 resp
->MessageType
= cpu_to_le32(RNDIS_KEEPALIVE_CMPLT
);
1017 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_keepalive_cmplt_type
));
1018 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
1019 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
1024 /* Prepare to receive the next packet */
1025 static void usb_net_reset_in_buf(USBNetState
*s
)
1027 s
->in_ptr
= s
->in_len
= 0;
1028 qemu_flush_queued_packets(qemu_get_queue(s
->nic
));
1031 static int rndis_parse(USBNetState
*s
, uint8_t *data
, int length
)
1033 uint32_t msg_type
= ldl_le_p(data
);
1036 case RNDIS_INITIALIZE_MSG
:
1037 s
->rndis_state
= RNDIS_INITIALIZED
;
1038 return rndis_init_response(s
, (rndis_init_msg_type
*) data
);
1040 case RNDIS_HALT_MSG
:
1041 s
->rndis_state
= RNDIS_UNINITIALIZED
;
1044 case RNDIS_QUERY_MSG
:
1045 return rndis_query_response(s
, (rndis_query_msg_type
*) data
, length
);
1048 return rndis_set_response(s
, (rndis_set_msg_type
*) data
, length
);
1050 case RNDIS_RESET_MSG
:
1051 rndis_clear_responsequeue(s
);
1053 usb_net_reset_in_buf(s
);
1054 return rndis_reset_response(s
, (rndis_reset_msg_type
*) data
);
1056 case RNDIS_KEEPALIVE_MSG
:
1057 /* For USB: host does this every 5 seconds */
1058 return rndis_keepalive_response(s
, (rndis_keepalive_msg_type
*) data
);
1061 return USB_RET_STALL
;
1064 static void usb_net_handle_reset(USBDevice
*dev
)
1068 static void usb_net_handle_control(USBDevice
*dev
, USBPacket
*p
,
1069 int request
, int value
, int index
, int length
, uint8_t *data
)
1071 USBNetState
*s
= (USBNetState
*) dev
;
1074 ret
= usb_desc_handle_control(dev
, p
, request
, value
, index
, length
, data
);
1080 case ClassInterfaceOutRequest
| USB_CDC_SEND_ENCAPSULATED_COMMAND
:
1081 if (!is_rndis(s
) || value
|| index
!= 0) {
1084 #ifdef TRAFFIC_DEBUG
1087 fprintf(stderr
, "SEND_ENCAPSULATED_COMMAND:");
1088 for (i
= 0; i
< length
; i
++) {
1090 fprintf(stderr
, "\n%04x:", i
);
1091 fprintf(stderr
, " %02x", data
[i
]);
1093 fprintf(stderr
, "\n\n");
1096 ret
= rndis_parse(s
, data
, length
);
1102 case ClassInterfaceRequest
| USB_CDC_GET_ENCAPSULATED_RESPONSE
:
1103 if (!is_rndis(s
) || value
|| index
!= 0) {
1106 p
->actual_length
= rndis_get_response(s
, data
);
1107 if (p
->actual_length
== 0) {
1109 p
->actual_length
= 1;
1111 #ifdef TRAFFIC_DEBUG
1114 fprintf(stderr
, "GET_ENCAPSULATED_RESPONSE:");
1115 for (i
= 0; i
< p
->actual_length
; i
++) {
1117 fprintf(stderr
, "\n%04x:", i
);
1118 fprintf(stderr
, " %02x", data
[i
]);
1120 fprintf(stderr
, "\n\n");
1127 fprintf(stderr
, "usbnet: failed control transaction: "
1128 "request 0x%x value 0x%x index 0x%x length 0x%x\n",
1129 request
, value
, index
, length
);
1130 p
->status
= USB_RET_STALL
;
1135 static void usb_net_handle_statusin(USBNetState
*s
, USBPacket
*p
)
1139 if (p
->iov
.size
< 8) {
1140 p
->status
= USB_RET_STALL
;
1144 buf
[0] = cpu_to_le32(1);
1145 buf
[1] = cpu_to_le32(0);
1146 usb_packet_copy(p
, buf
, 8);
1147 if (!s
->rndis_resp
.tqh_first
) {
1148 p
->status
= USB_RET_NAK
;
1151 #ifdef TRAFFIC_DEBUG
1152 fprintf(stderr
, "usbnet: interrupt poll len %zu return %d",
1153 p
->iov
.size
, p
->status
);
1154 iov_hexdump(p
->iov
.iov
, p
->iov
.niov
, stderr
, "usbnet", p
->status
);
1158 static void usb_net_handle_datain(USBNetState
*s
, USBPacket
*p
)
1162 if (s
->in_ptr
> s
->in_len
) {
1163 usb_net_reset_in_buf(s
);
1164 p
->status
= USB_RET_NAK
;
1168 p
->status
= USB_RET_NAK
;
1171 len
= s
->in_len
- s
->in_ptr
;
1172 if (len
> p
->iov
.size
) {
1175 usb_packet_copy(p
, &s
->in_buf
[s
->in_ptr
], len
);
1177 if (s
->in_ptr
>= s
->in_len
&&
1178 (is_rndis(s
) || (s
->in_len
& (64 - 1)) || !len
)) {
1179 /* no short packet necessary */
1180 usb_net_reset_in_buf(s
);
1183 #ifdef TRAFFIC_DEBUG
1184 fprintf(stderr
, "usbnet: data in len %zu return %d", p
->iov
.size
, len
);
1185 iov_hexdump(p
->iov
.iov
, p
->iov
.niov
, stderr
, "usbnet", len
);
1189 static void usb_net_handle_dataout(USBNetState
*s
, USBPacket
*p
)
1191 int sz
= sizeof(s
->out_buf
) - s
->out_ptr
;
1192 struct rndis_packet_msg_type
*msg
=
1193 (struct rndis_packet_msg_type
*) s
->out_buf
;
1196 #ifdef TRAFFIC_DEBUG
1197 fprintf(stderr
, "usbnet: data out len %zu\n", p
->iov
.size
);
1198 iov_hexdump(p
->iov
.iov
, p
->iov
.niov
, stderr
, "usbnet", p
->iov
.size
);
1201 if (sz
> p
->iov
.size
) {
1204 usb_packet_copy(p
, &s
->out_buf
[s
->out_ptr
], sz
);
1208 if (p
->iov
.size
< 64) {
1209 qemu_send_packet(qemu_get_queue(s
->nic
), s
->out_buf
, s
->out_ptr
);
1214 len
= le32_to_cpu(msg
->MessageLength
);
1215 if (s
->out_ptr
< 8 || s
->out_ptr
< len
) {
1218 if (le32_to_cpu(msg
->MessageType
) == RNDIS_PACKET_MSG
) {
1219 uint32_t offs
= 8 + le32_to_cpu(msg
->DataOffset
);
1220 uint32_t size
= le32_to_cpu(msg
->DataLength
);
1221 if (offs
< len
&& size
< len
&& offs
+ size
<= len
) {
1222 qemu_send_packet(qemu_get_queue(s
->nic
), s
->out_buf
+ offs
, size
);
1226 memmove(s
->out_buf
, &s
->out_buf
[len
], s
->out_ptr
);
1229 static void usb_net_handle_data(USBDevice
*dev
, USBPacket
*p
)
1231 USBNetState
*s
= (USBNetState
*) dev
;
1235 switch (p
->ep
->nr
) {
1237 usb_net_handle_statusin(s
, p
);
1241 usb_net_handle_datain(s
, p
);
1250 switch (p
->ep
->nr
) {
1252 usb_net_handle_dataout(s
, p
);
1262 p
->status
= USB_RET_STALL
;
1266 if (p
->status
== USB_RET_STALL
) {
1267 fprintf(stderr
, "usbnet: failed data transaction: "
1268 "pid 0x%x ep 0x%x len 0x%zx\n",
1269 p
->pid
, p
->ep
->nr
, p
->iov
.size
);
1273 static ssize_t
usbnet_receive(NetClientState
*nc
, const uint8_t *buf
, size_t size
)
1275 USBNetState
*s
= qemu_get_nic_opaque(nc
);
1276 uint8_t *in_buf
= s
->in_buf
;
1277 size_t total_size
= size
;
1279 if (!s
->dev
.config
) {
1284 if (s
->rndis_state
!= RNDIS_DATA_INITIALIZED
) {
1287 total_size
+= sizeof(struct rndis_packet_msg_type
);
1289 if (total_size
> sizeof(s
->in_buf
)) {
1293 /* Only accept packet if input buffer is empty */
1294 if (s
->in_len
> 0) {
1299 struct rndis_packet_msg_type
*msg
;
1301 msg
= (struct rndis_packet_msg_type
*)in_buf
;
1302 memset(msg
, 0, sizeof(struct rndis_packet_msg_type
));
1303 msg
->MessageType
= cpu_to_le32(RNDIS_PACKET_MSG
);
1304 msg
->MessageLength
= cpu_to_le32(size
+ sizeof(*msg
));
1305 msg
->DataOffset
= cpu_to_le32(sizeof(*msg
) - 8);
1306 msg
->DataLength
= cpu_to_le32(size
);
1307 /* msg->OOBDataOffset;
1308 * msg->OOBDataLength;
1309 * msg->NumOOBDataElements;
1310 * msg->PerPacketInfoOffset;
1311 * msg->PerPacketInfoLength;
1315 in_buf
+= sizeof(*msg
);
1318 memcpy(in_buf
, buf
, size
);
1319 s
->in_len
= total_size
;
1324 static void usbnet_cleanup(NetClientState
*nc
)
1326 USBNetState
*s
= qemu_get_nic_opaque(nc
);
1331 static void usb_net_unrealize(USBDevice
*dev
)
1333 USBNetState
*s
= (USBNetState
*) dev
;
1335 /* TODO: remove the nd_table[] entry */
1336 rndis_clear_responsequeue(s
);
1337 qemu_del_nic(s
->nic
);
1340 static NetClientInfo net_usbnet_info
= {
1341 .type
= NET_CLIENT_DRIVER_NIC
,
1342 .size
= sizeof(NICState
),
1343 .receive
= usbnet_receive
,
1344 .cleanup
= usbnet_cleanup
,
1347 static void usb_net_realize(USBDevice
*dev
, Error
**errp
)
1349 USBNetState
*s
= USB_NET(dev
);
1351 usb_desc_create_serial(dev
);
1354 s
->rndis_state
= RNDIS_UNINITIALIZED
;
1355 QTAILQ_INIT(&s
->rndis_resp
);
1357 s
->medium
= 0; /* NDIS_MEDIUM_802_3 */
1358 s
->speed
= 1000000; /* 100MBps, in 100Bps units */
1359 s
->media_state
= 0; /* NDIS_MEDIA_STATE_CONNECTED */;
1361 s
->vendorid
= 0x1234;
1362 s
->intr
= usb_ep_get(dev
, USB_TOKEN_IN
, 1);
1364 qemu_macaddr_default_if_unset(&s
->conf
.macaddr
);
1365 s
->nic
= qemu_new_nic(&net_usbnet_info
, &s
->conf
,
1366 object_get_typename(OBJECT(s
)), s
->dev
.qdev
.id
, s
);
1367 qemu_format_nic_info_str(qemu_get_queue(s
->nic
), s
->conf
.macaddr
.a
);
1368 snprintf(s
->usbstring_mac
, sizeof(s
->usbstring_mac
),
1369 "%02x%02x%02x%02x%02x%02x",
1371 s
->conf
.macaddr
.a
[1],
1372 s
->conf
.macaddr
.a
[2],
1373 s
->conf
.macaddr
.a
[3],
1374 s
->conf
.macaddr
.a
[4],
1375 s
->conf
.macaddr
.a
[5]);
1376 usb_desc_set_string(dev
, STRING_ETHADDR
, s
->usbstring_mac
);
1379 static void usb_net_instance_init(Object
*obj
)
1381 USBDevice
*dev
= USB_DEVICE(obj
);
1382 USBNetState
*s
= USB_NET(dev
);
1384 device_add_bootindex_property(obj
, &s
->conf
.bootindex
,
1385 "bootindex", "/ethernet-phy@0",
1389 static const VMStateDescription vmstate_usb_net
= {
1394 static Property net_properties
[] = {
1395 DEFINE_NIC_PROPERTIES(USBNetState
, conf
),
1396 DEFINE_PROP_END_OF_LIST(),
1399 static void usb_net_class_initfn(ObjectClass
*klass
, void *data
)
1401 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1402 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
1404 uc
->realize
= usb_net_realize
;
1405 uc
->product_desc
= "QEMU USB Network Interface";
1406 uc
->usb_desc
= &desc_net
;
1407 uc
->handle_reset
= usb_net_handle_reset
;
1408 uc
->handle_control
= usb_net_handle_control
;
1409 uc
->handle_data
= usb_net_handle_data
;
1410 uc
->unrealize
= usb_net_unrealize
;
1411 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1412 dc
->fw_name
= "network";
1413 dc
->vmsd
= &vmstate_usb_net
;
1414 device_class_set_props(dc
, net_properties
);
1417 static const TypeInfo net_info
= {
1418 .name
= TYPE_USB_NET
,
1419 .parent
= TYPE_USB_DEVICE
,
1420 .instance_size
= sizeof(USBNetState
),
1421 .class_init
= usb_net_class_initfn
,
1422 .instance_init
= usb_net_instance_init
,
1425 static void usb_net_register_types(void)
1427 type_register_static(&net_info
);
1430 type_init(usb_net_register_types
)