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 "qemu-common.h"
29 #include "hw/usb/desc.h"
31 #include "qemu/error-report.h"
32 #include "qemu/queue.h"
33 #include "qemu/config-file.h"
34 #include "sysemu/sysemu.h"
37 /*#define TRAFFIC_DEBUG*/
38 /* Thanks to NetChip Technologies for donating this product ID.
39 * It's for devices with only CDC Ethernet configurations.
41 #define CDC_VENDOR_NUM 0x0525 /* NetChip */
42 #define CDC_PRODUCT_NUM 0xa4a1 /* Linux-USB Ethernet Gadget */
43 /* For hardware that can talk RNDIS and either of the above protocols,
44 * use this ID ... the windows INF files will know it.
46 #define RNDIS_VENDOR_NUM 0x0525 /* NetChip */
47 #define RNDIS_PRODUCT_NUM 0xa4a2 /* Ethernet/RNDIS Gadget */
50 STRING_MANUFACTURER
= 1,
62 #define DEV_CONFIG_VALUE 1 /* CDC or a subset */
63 #define DEV_RNDIS_CONFIG_VALUE 2 /* RNDIS; optional */
65 #define USB_CDC_SUBCLASS_ACM 0x02
66 #define USB_CDC_SUBCLASS_ETHERNET 0x06
68 #define USB_CDC_PROTO_NONE 0
69 #define USB_CDC_ACM_PROTO_VENDOR 0xff
71 #define USB_CDC_HEADER_TYPE 0x00 /* header_desc */
72 #define USB_CDC_CALL_MANAGEMENT_TYPE 0x01 /* call_mgmt_descriptor */
73 #define USB_CDC_ACM_TYPE 0x02 /* acm_descriptor */
74 #define USB_CDC_UNION_TYPE 0x06 /* union_desc */
75 #define USB_CDC_ETHERNET_TYPE 0x0f /* ether_desc */
77 #define USB_CDC_SEND_ENCAPSULATED_COMMAND 0x00
78 #define USB_CDC_GET_ENCAPSULATED_RESPONSE 0x01
79 #define USB_CDC_REQ_SET_LINE_CODING 0x20
80 #define USB_CDC_REQ_GET_LINE_CODING 0x21
81 #define USB_CDC_REQ_SET_CONTROL_LINE_STATE 0x22
82 #define USB_CDC_REQ_SEND_BREAK 0x23
83 #define USB_CDC_SET_ETHERNET_MULTICAST_FILTERS 0x40
84 #define USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER 0x41
85 #define USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER 0x42
86 #define USB_CDC_SET_ETHERNET_PACKET_FILTER 0x43
87 #define USB_CDC_GET_ETHERNET_STATISTIC 0x44
89 #define LOG2_STATUS_INTERVAL_MSEC 5 /* 1 << 5 == 32 msec */
90 #define STATUS_BYTECOUNT 16 /* 8 byte header + data */
92 #define ETH_FRAME_LEN 1514 /* Max. octets in frame sans FCS */
94 static const USBDescStrings usb_net_stringtable
= {
95 [STRING_MANUFACTURER
] = "QEMU",
96 [STRING_PRODUCT
] = "RNDIS/QEMU USB Network Device",
97 [STRING_ETHADDR
] = "400102030405",
98 [STRING_DATA
] = "QEMU USB Net Data Interface",
99 [STRING_CONTROL
] = "QEMU USB Net Control Interface",
100 [STRING_RNDIS_CONTROL
] = "QEMU USB Net RNDIS Control Interface",
101 [STRING_CDC
] = "QEMU USB Net CDC",
102 [STRING_SUBSET
] = "QEMU USB Net Subset",
103 [STRING_RNDIS
] = "QEMU USB Net RNDIS",
104 [STRING_SERIALNUMBER
] = "1",
107 static const USBDescIface desc_iface_rndis
[] = {
109 /* RNDIS Control Interface */
110 .bInterfaceNumber
= 0,
112 .bInterfaceClass
= USB_CLASS_COMM
,
113 .bInterfaceSubClass
= USB_CDC_SUBCLASS_ACM
,
114 .bInterfaceProtocol
= USB_CDC_ACM_PROTO_VENDOR
,
115 .iInterface
= STRING_RNDIS_CONTROL
,
117 .descs
= (USBDescOther
[]) {
119 /* Header Descriptor */
120 .data
= (uint8_t[]) {
121 0x05, /* u8 bLength */
122 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
123 USB_CDC_HEADER_TYPE
, /* u8 bDescriptorSubType */
124 0x10, 0x01, /* le16 bcdCDC */
127 /* Call Management Descriptor */
128 .data
= (uint8_t[]) {
129 0x05, /* u8 bLength */
130 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
131 USB_CDC_CALL_MANAGEMENT_TYPE
, /* u8 bDescriptorSubType */
132 0x00, /* u8 bmCapabilities */
133 0x01, /* u8 bDataInterface */
137 .data
= (uint8_t[]) {
138 0x04, /* u8 bLength */
139 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
140 USB_CDC_ACM_TYPE
, /* u8 bDescriptorSubType */
141 0x00, /* u8 bmCapabilities */
144 /* Union Descriptor */
145 .data
= (uint8_t[]) {
146 0x05, /* u8 bLength */
147 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
148 USB_CDC_UNION_TYPE
, /* u8 bDescriptorSubType */
149 0x00, /* u8 bMasterInterface0 */
150 0x01, /* u8 bSlaveInterface0 */
154 .eps
= (USBDescEndpoint
[]) {
156 .bEndpointAddress
= USB_DIR_IN
| 0x01,
157 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
158 .wMaxPacketSize
= STATUS_BYTECOUNT
,
159 .bInterval
= 1 << LOG2_STATUS_INTERVAL_MSEC
,
163 /* RNDIS Data Interface */
164 .bInterfaceNumber
= 1,
166 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
167 .iInterface
= STRING_DATA
,
168 .eps
= (USBDescEndpoint
[]) {
170 .bEndpointAddress
= USB_DIR_IN
| 0x02,
171 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
172 .wMaxPacketSize
= 0x40,
174 .bEndpointAddress
= USB_DIR_OUT
| 0x02,
175 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
176 .wMaxPacketSize
= 0x40,
182 static const USBDescIface desc_iface_cdc
[] = {
184 /* CDC Control Interface */
185 .bInterfaceNumber
= 0,
187 .bInterfaceClass
= USB_CLASS_COMM
,
188 .bInterfaceSubClass
= USB_CDC_SUBCLASS_ETHERNET
,
189 .bInterfaceProtocol
= USB_CDC_PROTO_NONE
,
190 .iInterface
= STRING_CONTROL
,
192 .descs
= (USBDescOther
[]) {
194 /* Header Descriptor */
195 .data
= (uint8_t[]) {
196 0x05, /* u8 bLength */
197 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
198 USB_CDC_HEADER_TYPE
, /* u8 bDescriptorSubType */
199 0x10, 0x01, /* le16 bcdCDC */
202 /* Union Descriptor */
203 .data
= (uint8_t[]) {
204 0x05, /* u8 bLength */
205 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
206 USB_CDC_UNION_TYPE
, /* u8 bDescriptorSubType */
207 0x00, /* u8 bMasterInterface0 */
208 0x01, /* u8 bSlaveInterface0 */
211 /* Ethernet Descriptor */
212 .data
= (uint8_t[]) {
213 0x0d, /* u8 bLength */
214 USB_DT_CS_INTERFACE
, /* u8 bDescriptorType */
215 USB_CDC_ETHERNET_TYPE
, /* u8 bDescriptorSubType */
216 STRING_ETHADDR
, /* u8 iMACAddress */
217 0x00, 0x00, 0x00, 0x00, /* le32 bmEthernetStatistics */
218 ETH_FRAME_LEN
& 0xff,
219 ETH_FRAME_LEN
>> 8, /* le16 wMaxSegmentSize */
220 0x00, 0x00, /* le16 wNumberMCFilters */
221 0x00, /* u8 bNumberPowerFilters */
225 .eps
= (USBDescEndpoint
[]) {
227 .bEndpointAddress
= USB_DIR_IN
| 0x01,
228 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
229 .wMaxPacketSize
= STATUS_BYTECOUNT
,
230 .bInterval
= 1 << LOG2_STATUS_INTERVAL_MSEC
,
234 /* CDC Data Interface (off) */
235 .bInterfaceNumber
= 1,
236 .bAlternateSetting
= 0,
238 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
240 /* CDC Data Interface */
241 .bInterfaceNumber
= 1,
242 .bAlternateSetting
= 1,
244 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
245 .iInterface
= STRING_DATA
,
246 .eps
= (USBDescEndpoint
[]) {
248 .bEndpointAddress
= USB_DIR_IN
| 0x02,
249 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
250 .wMaxPacketSize
= 0x40,
252 .bEndpointAddress
= USB_DIR_OUT
| 0x02,
253 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
254 .wMaxPacketSize
= 0x40,
260 static const USBDescDevice desc_device_net
= {
262 .bDeviceClass
= USB_CLASS_COMM
,
263 .bMaxPacketSize0
= 0x40,
264 .bNumConfigurations
= 2,
265 .confs
= (USBDescConfig
[]) {
268 .bConfigurationValue
= DEV_RNDIS_CONFIG_VALUE
,
269 .iConfiguration
= STRING_RNDIS
,
270 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_SELFPOWER
,
272 .nif
= ARRAY_SIZE(desc_iface_rndis
),
273 .ifs
= desc_iface_rndis
,
276 .bConfigurationValue
= DEV_CONFIG_VALUE
,
277 .iConfiguration
= STRING_CDC
,
278 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_SELFPOWER
,
280 .nif
= ARRAY_SIZE(desc_iface_cdc
),
281 .ifs
= desc_iface_cdc
,
286 static const USBDesc desc_net
= {
288 .idVendor
= RNDIS_VENDOR_NUM
,
289 .idProduct
= RNDIS_PRODUCT_NUM
,
291 .iManufacturer
= STRING_MANUFACTURER
,
292 .iProduct
= STRING_PRODUCT
,
293 .iSerialNumber
= STRING_SERIALNUMBER
,
295 .full
= &desc_device_net
,
296 .str
= usb_net_stringtable
,
300 * RNDIS Definitions - in theory not specific to USB.
302 #define RNDIS_MAXIMUM_FRAME_SIZE 1518
303 #define RNDIS_MAX_TOTAL_SIZE 1558
305 /* Remote NDIS Versions */
306 #define RNDIS_MAJOR_VERSION 1
307 #define RNDIS_MINOR_VERSION 0
310 #define RNDIS_STATUS_SUCCESS 0x00000000U /* Success */
311 #define RNDIS_STATUS_FAILURE 0xc0000001U /* Unspecified error */
312 #define RNDIS_STATUS_INVALID_DATA 0xc0010015U /* Invalid data */
313 #define RNDIS_STATUS_NOT_SUPPORTED 0xc00000bbU /* Unsupported request */
314 #define RNDIS_STATUS_MEDIA_CONNECT 0x4001000bU /* Device connected */
315 #define RNDIS_STATUS_MEDIA_DISCONNECT 0x4001000cU /* Device disconnected */
317 /* Message Set for Connectionless (802.3) Devices */
319 RNDIS_PACKET_MSG
= 1,
320 RNDIS_INITIALIZE_MSG
= 2, /* Initialize device */
325 RNDIS_INDICATE_STATUS_MSG
= 7,
326 RNDIS_KEEPALIVE_MSG
= 8,
329 /* Message completion */
331 RNDIS_INITIALIZE_CMPLT
= 0x80000002U
,
332 RNDIS_QUERY_CMPLT
= 0x80000004U
,
333 RNDIS_SET_CMPLT
= 0x80000005U
,
334 RNDIS_RESET_CMPLT
= 0x80000006U
,
335 RNDIS_KEEPALIVE_CMPLT
= 0x80000008U
,
340 RNDIS_DF_CONNECTIONLESS
= 1,
341 RNDIS_DF_CONNECTIONORIENTED
= 2,
344 #define RNDIS_MEDIUM_802_3 0x00000000U
346 /* from drivers/net/sk98lin/h/skgepnmi.h */
347 #define OID_PNP_CAPABILITIES 0xfd010100
348 #define OID_PNP_SET_POWER 0xfd010101
349 #define OID_PNP_QUERY_POWER 0xfd010102
350 #define OID_PNP_ADD_WAKE_UP_PATTERN 0xfd010103
351 #define OID_PNP_REMOVE_WAKE_UP_PATTERN 0xfd010104
352 #define OID_PNP_ENABLE_WAKE_UP 0xfd010106
354 typedef uint32_t le32
;
356 typedef struct rndis_init_msg_type
{
362 le32 MaxTransferSize
;
363 } rndis_init_msg_type
;
365 typedef struct rndis_init_cmplt_type
{
374 le32 MaxPacketsPerTransfer
;
375 le32 MaxTransferSize
;
376 le32 PacketAlignmentFactor
;
379 } rndis_init_cmplt_type
;
381 typedef struct rndis_halt_msg_type
{
385 } rndis_halt_msg_type
;
387 typedef struct rndis_query_msg_type
{
392 le32 InformationBufferLength
;
393 le32 InformationBufferOffset
;
395 } rndis_query_msg_type
;
397 typedef struct rndis_query_cmplt_type
{
402 le32 InformationBufferLength
;
403 le32 InformationBufferOffset
;
404 } rndis_query_cmplt_type
;
406 typedef struct rndis_set_msg_type
{
411 le32 InformationBufferLength
;
412 le32 InformationBufferOffset
;
414 } rndis_set_msg_type
;
416 typedef struct rndis_set_cmplt_type
{
421 } rndis_set_cmplt_type
;
423 typedef struct rndis_reset_msg_type
{
427 } rndis_reset_msg_type
;
429 typedef struct rndis_reset_cmplt_type
{
433 le32 AddressingReset
;
434 } rndis_reset_cmplt_type
;
436 typedef struct rndis_indicate_status_msg_type
{
440 le32 StatusBufferLength
;
441 le32 StatusBufferOffset
;
442 } rndis_indicate_status_msg_type
;
444 typedef struct rndis_keepalive_msg_type
{
448 } rndis_keepalive_msg_type
;
450 typedef struct rndis_keepalive_cmplt_type
{
455 } rndis_keepalive_cmplt_type
;
457 struct rndis_packet_msg_type
{
464 le32 NumOOBDataElements
;
465 le32 PerPacketInfoOffset
;
466 le32 PerPacketInfoLength
;
471 struct rndis_config_parameter
{
472 le32 ParameterNameOffset
;
473 le32 ParameterNameLength
;
475 le32 ParameterValueOffset
;
476 le32 ParameterValueLength
;
479 /* implementation specific */
484 RNDIS_DATA_INITIALIZED
,
489 /* Required Object IDs (OIDs) */
490 OID_GEN_SUPPORTED_LIST
= 0x00010101,
491 OID_GEN_HARDWARE_STATUS
= 0x00010102,
492 OID_GEN_MEDIA_SUPPORTED
= 0x00010103,
493 OID_GEN_MEDIA_IN_USE
= 0x00010104,
494 OID_GEN_MAXIMUM_LOOKAHEAD
= 0x00010105,
495 OID_GEN_MAXIMUM_FRAME_SIZE
= 0x00010106,
496 OID_GEN_LINK_SPEED
= 0x00010107,
497 OID_GEN_TRANSMIT_BUFFER_SPACE
= 0x00010108,
498 OID_GEN_RECEIVE_BUFFER_SPACE
= 0x00010109,
499 OID_GEN_TRANSMIT_BLOCK_SIZE
= 0x0001010a,
500 OID_GEN_RECEIVE_BLOCK_SIZE
= 0x0001010b,
501 OID_GEN_VENDOR_ID
= 0x0001010c,
502 OID_GEN_VENDOR_DESCRIPTION
= 0x0001010d,
503 OID_GEN_CURRENT_PACKET_FILTER
= 0x0001010e,
504 OID_GEN_CURRENT_LOOKAHEAD
= 0x0001010f,
505 OID_GEN_DRIVER_VERSION
= 0x00010110,
506 OID_GEN_MAXIMUM_TOTAL_SIZE
= 0x00010111,
507 OID_GEN_PROTOCOL_OPTIONS
= 0x00010112,
508 OID_GEN_MAC_OPTIONS
= 0x00010113,
509 OID_GEN_MEDIA_CONNECT_STATUS
= 0x00010114,
510 OID_GEN_MAXIMUM_SEND_PACKETS
= 0x00010115,
511 OID_GEN_VENDOR_DRIVER_VERSION
= 0x00010116,
512 OID_GEN_SUPPORTED_GUIDS
= 0x00010117,
513 OID_GEN_NETWORK_LAYER_ADDRESSES
= 0x00010118,
514 OID_GEN_TRANSPORT_HEADER_OFFSET
= 0x00010119,
515 OID_GEN_MACHINE_NAME
= 0x0001021a,
516 OID_GEN_RNDIS_CONFIG_PARAMETER
= 0x0001021b,
517 OID_GEN_VLAN_ID
= 0x0001021c,
520 OID_GEN_MEDIA_CAPABILITIES
= 0x00010201,
521 OID_GEN_PHYSICAL_MEDIUM
= 0x00010202,
523 /* Required statistics OIDs */
524 OID_GEN_XMIT_OK
= 0x00020101,
525 OID_GEN_RCV_OK
= 0x00020102,
526 OID_GEN_XMIT_ERROR
= 0x00020103,
527 OID_GEN_RCV_ERROR
= 0x00020104,
528 OID_GEN_RCV_NO_BUFFER
= 0x00020105,
530 /* Optional statistics OIDs */
531 OID_GEN_DIRECTED_BYTES_XMIT
= 0x00020201,
532 OID_GEN_DIRECTED_FRAMES_XMIT
= 0x00020202,
533 OID_GEN_MULTICAST_BYTES_XMIT
= 0x00020203,
534 OID_GEN_MULTICAST_FRAMES_XMIT
= 0x00020204,
535 OID_GEN_BROADCAST_BYTES_XMIT
= 0x00020205,
536 OID_GEN_BROADCAST_FRAMES_XMIT
= 0x00020206,
537 OID_GEN_DIRECTED_BYTES_RCV
= 0x00020207,
538 OID_GEN_DIRECTED_FRAMES_RCV
= 0x00020208,
539 OID_GEN_MULTICAST_BYTES_RCV
= 0x00020209,
540 OID_GEN_MULTICAST_FRAMES_RCV
= 0x0002020a,
541 OID_GEN_BROADCAST_BYTES_RCV
= 0x0002020b,
542 OID_GEN_BROADCAST_FRAMES_RCV
= 0x0002020c,
543 OID_GEN_RCV_CRC_ERROR
= 0x0002020d,
544 OID_GEN_TRANSMIT_QUEUE_LENGTH
= 0x0002020e,
545 OID_GEN_GET_TIME_CAPS
= 0x0002020f,
546 OID_GEN_GET_NETCARD_TIME
= 0x00020210,
547 OID_GEN_NETCARD_LOAD
= 0x00020211,
548 OID_GEN_DEVICE_PROFILE
= 0x00020212,
549 OID_GEN_INIT_TIME_MS
= 0x00020213,
550 OID_GEN_RESET_COUNTS
= 0x00020214,
551 OID_GEN_MEDIA_SENSE_COUNTS
= 0x00020215,
552 OID_GEN_FRIENDLY_NAME
= 0x00020216,
553 OID_GEN_MINIPORT_INFO
= 0x00020217,
554 OID_GEN_RESET_VERIFY_PARAMETERS
= 0x00020218,
556 /* IEEE 802.3 (Ethernet) OIDs */
557 OID_802_3_PERMANENT_ADDRESS
= 0x01010101,
558 OID_802_3_CURRENT_ADDRESS
= 0x01010102,
559 OID_802_3_MULTICAST_LIST
= 0x01010103,
560 OID_802_3_MAXIMUM_LIST_SIZE
= 0x01010104,
561 OID_802_3_MAC_OPTIONS
= 0x01010105,
562 OID_802_3_RCV_ERROR_ALIGNMENT
= 0x01020101,
563 OID_802_3_XMIT_ONE_COLLISION
= 0x01020102,
564 OID_802_3_XMIT_MORE_COLLISIONS
= 0x01020103,
565 OID_802_3_XMIT_DEFERRED
= 0x01020201,
566 OID_802_3_XMIT_MAX_COLLISIONS
= 0x01020202,
567 OID_802_3_RCV_OVERRUN
= 0x01020203,
568 OID_802_3_XMIT_UNDERRUN
= 0x01020204,
569 OID_802_3_XMIT_HEARTBEAT_FAILURE
= 0x01020205,
570 OID_802_3_XMIT_TIMES_CRS_LOST
= 0x01020206,
571 OID_802_3_XMIT_LATE_COLLISIONS
= 0x01020207,
574 static const uint32_t oid_supported_list
[] =
576 /* the general stuff */
577 OID_GEN_SUPPORTED_LIST
,
578 OID_GEN_HARDWARE_STATUS
,
579 OID_GEN_MEDIA_SUPPORTED
,
580 OID_GEN_MEDIA_IN_USE
,
581 OID_GEN_MAXIMUM_FRAME_SIZE
,
583 OID_GEN_TRANSMIT_BLOCK_SIZE
,
584 OID_GEN_RECEIVE_BLOCK_SIZE
,
586 OID_GEN_VENDOR_DESCRIPTION
,
587 OID_GEN_VENDOR_DRIVER_VERSION
,
588 OID_GEN_CURRENT_PACKET_FILTER
,
589 OID_GEN_MAXIMUM_TOTAL_SIZE
,
590 OID_GEN_MEDIA_CONNECT_STATUS
,
591 OID_GEN_PHYSICAL_MEDIUM
,
593 /* the statistical stuff */
598 OID_GEN_RCV_NO_BUFFER
,
601 /* the general stuff */
602 OID_802_3_PERMANENT_ADDRESS
,
603 OID_802_3_CURRENT_ADDRESS
,
604 OID_802_3_MULTICAST_LIST
,
605 OID_802_3_MAC_OPTIONS
,
606 OID_802_3_MAXIMUM_LIST_SIZE
,
608 /* the statistical stuff */
609 OID_802_3_RCV_ERROR_ALIGNMENT
,
610 OID_802_3_XMIT_ONE_COLLISION
,
611 OID_802_3_XMIT_MORE_COLLISIONS
,
614 #define NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA (1 << 0)
615 #define NDIS_MAC_OPTION_RECEIVE_SERIALIZED (1 << 1)
616 #define NDIS_MAC_OPTION_TRANSFERS_NOT_PEND (1 << 2)
617 #define NDIS_MAC_OPTION_NO_LOOPBACK (1 << 3)
618 #define NDIS_MAC_OPTION_FULL_DUPLEX (1 << 4)
619 #define NDIS_MAC_OPTION_EOTX_INDICATION (1 << 5)
620 #define NDIS_MAC_OPTION_8021P_PRIORITY (1 << 6)
622 struct rndis_response
{
623 QTAILQ_ENTRY(rndis_response
) entries
;
628 typedef struct USBNetState
{
631 enum rndis_state rndis_state
;
634 uint32_t media_state
;
638 unsigned int out_ptr
;
639 uint8_t out_buf
[2048];
641 unsigned int in_ptr
, in_len
;
642 uint8_t in_buf
[2048];
646 char usbstring_mac
[13];
649 QTAILQ_HEAD(rndis_resp_head
, rndis_response
) rndis_resp
;
652 #define TYPE_USB_NET "usb-net"
653 #define USB_NET(obj) OBJECT_CHECK(USBNetState, (obj), TYPE_USB_NET)
655 static int is_rndis(USBNetState
*s
)
657 return s
->dev
.config
?
658 s
->dev
.config
->bConfigurationValue
== DEV_RNDIS_CONFIG_VALUE
: 0;
661 static int ndis_query(USBNetState
*s
, uint32_t oid
,
662 uint8_t *inbuf
, unsigned int inlen
, uint8_t *outbuf
,
668 /* general oids (table 4-1) */
670 case OID_GEN_SUPPORTED_LIST
:
671 for (i
= 0; i
< ARRAY_SIZE(oid_supported_list
); i
++)
672 ((le32
*) outbuf
)[i
] = cpu_to_le32(oid_supported_list
[i
]);
673 return sizeof(oid_supported_list
);
676 case OID_GEN_HARDWARE_STATUS
:
677 *((le32
*) outbuf
) = cpu_to_le32(0);
681 case OID_GEN_MEDIA_SUPPORTED
:
682 *((le32
*) outbuf
) = cpu_to_le32(s
->medium
);
686 case OID_GEN_MEDIA_IN_USE
:
687 *((le32
*) outbuf
) = cpu_to_le32(s
->medium
);
691 case OID_GEN_MAXIMUM_FRAME_SIZE
:
692 *((le32
*) outbuf
) = cpu_to_le32(ETH_FRAME_LEN
);
696 case OID_GEN_LINK_SPEED
:
697 *((le32
*) outbuf
) = cpu_to_le32(s
->speed
);
701 case OID_GEN_TRANSMIT_BLOCK_SIZE
:
702 *((le32
*) outbuf
) = cpu_to_le32(ETH_FRAME_LEN
);
706 case OID_GEN_RECEIVE_BLOCK_SIZE
:
707 *((le32
*) outbuf
) = cpu_to_le32(ETH_FRAME_LEN
);
711 case OID_GEN_VENDOR_ID
:
712 *((le32
*) outbuf
) = cpu_to_le32(s
->vendorid
);
716 case OID_GEN_VENDOR_DESCRIPTION
:
717 pstrcpy((char *)outbuf
, outlen
, "QEMU USB RNDIS Net");
718 return strlen((char *)outbuf
) + 1;
720 case OID_GEN_VENDOR_DRIVER_VERSION
:
721 *((le32
*) outbuf
) = cpu_to_le32(1);
725 case OID_GEN_CURRENT_PACKET_FILTER
:
726 *((le32
*) outbuf
) = cpu_to_le32(s
->filter
);
730 case OID_GEN_MAXIMUM_TOTAL_SIZE
:
731 *((le32
*) outbuf
) = cpu_to_le32(RNDIS_MAX_TOTAL_SIZE
);
735 case OID_GEN_MEDIA_CONNECT_STATUS
:
736 *((le32
*) outbuf
) = cpu_to_le32(s
->media_state
);
739 case OID_GEN_PHYSICAL_MEDIUM
:
740 *((le32
*) outbuf
) = cpu_to_le32(0);
743 case OID_GEN_MAC_OPTIONS
:
744 *((le32
*) outbuf
) = cpu_to_le32(
745 NDIS_MAC_OPTION_RECEIVE_SERIALIZED
|
746 NDIS_MAC_OPTION_FULL_DUPLEX
);
749 /* statistics OIDs (table 4-2) */
751 case OID_GEN_XMIT_OK
:
752 *((le32
*) outbuf
) = cpu_to_le32(0);
757 *((le32
*) outbuf
) = cpu_to_le32(0);
761 case OID_GEN_XMIT_ERROR
:
762 *((le32
*) outbuf
) = cpu_to_le32(0);
766 case OID_GEN_RCV_ERROR
:
767 *((le32
*) outbuf
) = cpu_to_le32(0);
771 case OID_GEN_RCV_NO_BUFFER
:
772 *((le32
*) outbuf
) = cpu_to_le32(0);
775 /* ieee802.3 OIDs (table 4-3) */
777 case OID_802_3_PERMANENT_ADDRESS
:
778 memcpy(outbuf
, s
->conf
.macaddr
.a
, 6);
782 case OID_802_3_CURRENT_ADDRESS
:
783 memcpy(outbuf
, s
->conf
.macaddr
.a
, 6);
787 case OID_802_3_MULTICAST_LIST
:
788 *((le32
*) outbuf
) = cpu_to_le32(0xe0000000);
792 case OID_802_3_MAXIMUM_LIST_SIZE
:
793 *((le32
*) outbuf
) = cpu_to_le32(1);
796 case OID_802_3_MAC_OPTIONS
:
799 /* ieee802.3 statistics OIDs (table 4-4) */
801 case OID_802_3_RCV_ERROR_ALIGNMENT
:
802 *((le32
*) outbuf
) = cpu_to_le32(0);
806 case OID_802_3_XMIT_ONE_COLLISION
:
807 *((le32
*) outbuf
) = cpu_to_le32(0);
811 case OID_802_3_XMIT_MORE_COLLISIONS
:
812 *((le32
*) outbuf
) = cpu_to_le32(0);
816 fprintf(stderr
, "usbnet: unknown OID 0x%08x\n", oid
);
822 static int ndis_set(USBNetState
*s
, uint32_t oid
,
823 uint8_t *inbuf
, unsigned int inlen
)
826 case OID_GEN_CURRENT_PACKET_FILTER
:
827 s
->filter
= le32_to_cpup((le32
*) inbuf
);
829 s
->rndis_state
= RNDIS_DATA_INITIALIZED
;
831 s
->rndis_state
= RNDIS_INITIALIZED
;
835 case OID_802_3_MULTICAST_LIST
:
841 static int rndis_get_response(USBNetState
*s
, uint8_t *buf
)
844 struct rndis_response
*r
= s
->rndis_resp
.tqh_first
;
849 QTAILQ_REMOVE(&s
->rndis_resp
, r
, entries
);
851 memcpy(buf
, r
->buf
, r
->length
);
857 static void *rndis_queue_response(USBNetState
*s
, unsigned int length
)
859 struct rndis_response
*r
=
860 g_malloc0(sizeof(struct rndis_response
) + length
);
862 if (QTAILQ_EMPTY(&s
->rndis_resp
)) {
863 usb_wakeup(s
->intr
, 0);
866 QTAILQ_INSERT_TAIL(&s
->rndis_resp
, r
, entries
);
872 static void rndis_clear_responsequeue(USBNetState
*s
)
874 struct rndis_response
*r
;
876 while ((r
= s
->rndis_resp
.tqh_first
)) {
877 QTAILQ_REMOVE(&s
->rndis_resp
, r
, entries
);
882 static int rndis_init_response(USBNetState
*s
, rndis_init_msg_type
*buf
)
884 rndis_init_cmplt_type
*resp
=
885 rndis_queue_response(s
, sizeof(rndis_init_cmplt_type
));
888 return USB_RET_STALL
;
890 resp
->MessageType
= cpu_to_le32(RNDIS_INITIALIZE_CMPLT
);
891 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_init_cmplt_type
));
892 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
893 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
894 resp
->MajorVersion
= cpu_to_le32(RNDIS_MAJOR_VERSION
);
895 resp
->MinorVersion
= cpu_to_le32(RNDIS_MINOR_VERSION
);
896 resp
->DeviceFlags
= cpu_to_le32(RNDIS_DF_CONNECTIONLESS
);
897 resp
->Medium
= cpu_to_le32(RNDIS_MEDIUM_802_3
);
898 resp
->MaxPacketsPerTransfer
= cpu_to_le32(1);
899 resp
->MaxTransferSize
= cpu_to_le32(ETH_FRAME_LEN
+
900 sizeof(struct rndis_packet_msg_type
) + 22);
901 resp
->PacketAlignmentFactor
= cpu_to_le32(0);
902 resp
->AFListOffset
= cpu_to_le32(0);
903 resp
->AFListSize
= cpu_to_le32(0);
907 static int rndis_query_response(USBNetState
*s
,
908 rndis_query_msg_type
*buf
, unsigned int length
)
910 rndis_query_cmplt_type
*resp
;
911 /* oid_supported_list is the largest data reply */
912 uint8_t infobuf
[sizeof(oid_supported_list
)];
913 uint32_t bufoffs
, buflen
;
915 unsigned int resplen
;
917 bufoffs
= le32_to_cpu(buf
->InformationBufferOffset
) + 8;
918 buflen
= le32_to_cpu(buf
->InformationBufferLength
);
919 if (bufoffs
+ buflen
> length
)
920 return USB_RET_STALL
;
922 infobuflen
= ndis_query(s
, le32_to_cpu(buf
->OID
),
923 bufoffs
+ (uint8_t *) buf
, buflen
, infobuf
,
925 resplen
= sizeof(rndis_query_cmplt_type
) +
926 ((infobuflen
< 0) ? 0 : infobuflen
);
927 resp
= rndis_queue_response(s
, resplen
);
929 return USB_RET_STALL
;
931 resp
->MessageType
= cpu_to_le32(RNDIS_QUERY_CMPLT
);
932 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
933 resp
->MessageLength
= cpu_to_le32(resplen
);
935 if (infobuflen
< 0) {
936 /* OID not supported */
937 resp
->Status
= cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED
);
938 resp
->InformationBufferLength
= cpu_to_le32(0);
939 resp
->InformationBufferOffset
= cpu_to_le32(0);
943 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
944 resp
->InformationBufferOffset
=
945 cpu_to_le32(infobuflen
? sizeof(rndis_query_cmplt_type
) - 8 : 0);
946 resp
->InformationBufferLength
= cpu_to_le32(infobuflen
);
947 memcpy(resp
+ 1, infobuf
, infobuflen
);
952 static int rndis_set_response(USBNetState
*s
,
953 rndis_set_msg_type
*buf
, unsigned int length
)
955 rndis_set_cmplt_type
*resp
=
956 rndis_queue_response(s
, sizeof(rndis_set_cmplt_type
));
957 uint32_t bufoffs
, buflen
;
961 return USB_RET_STALL
;
963 bufoffs
= le32_to_cpu(buf
->InformationBufferOffset
) + 8;
964 buflen
= le32_to_cpu(buf
->InformationBufferLength
);
965 if (bufoffs
+ buflen
> length
)
966 return USB_RET_STALL
;
968 ret
= ndis_set(s
, le32_to_cpu(buf
->OID
),
969 bufoffs
+ (uint8_t *) buf
, buflen
);
970 resp
->MessageType
= cpu_to_le32(RNDIS_SET_CMPLT
);
971 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
972 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_set_cmplt_type
));
974 /* OID not supported */
975 resp
->Status
= cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED
);
978 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
983 static int rndis_reset_response(USBNetState
*s
, rndis_reset_msg_type
*buf
)
985 rndis_reset_cmplt_type
*resp
=
986 rndis_queue_response(s
, sizeof(rndis_reset_cmplt_type
));
989 return USB_RET_STALL
;
991 resp
->MessageType
= cpu_to_le32(RNDIS_RESET_CMPLT
);
992 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_reset_cmplt_type
));
993 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
994 resp
->AddressingReset
= cpu_to_le32(1); /* reset information */
999 static int rndis_keepalive_response(USBNetState
*s
,
1000 rndis_keepalive_msg_type
*buf
)
1002 rndis_keepalive_cmplt_type
*resp
=
1003 rndis_queue_response(s
, sizeof(rndis_keepalive_cmplt_type
));
1006 return USB_RET_STALL
;
1008 resp
->MessageType
= cpu_to_le32(RNDIS_KEEPALIVE_CMPLT
);
1009 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_keepalive_cmplt_type
));
1010 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
1011 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
1016 /* Prepare to receive the next packet */
1017 static void usb_net_reset_in_buf(USBNetState
*s
)
1019 s
->in_ptr
= s
->in_len
= 0;
1020 qemu_flush_queued_packets(qemu_get_queue(s
->nic
));
1023 static int rndis_parse(USBNetState
*s
, uint8_t *data
, int length
)
1026 le32
*tmp
= (le32
*) data
;
1028 msg_type
= le32_to_cpup(tmp
);
1031 case RNDIS_INITIALIZE_MSG
:
1032 s
->rndis_state
= RNDIS_INITIALIZED
;
1033 return rndis_init_response(s
, (rndis_init_msg_type
*) data
);
1035 case RNDIS_HALT_MSG
:
1036 s
->rndis_state
= RNDIS_UNINITIALIZED
;
1039 case RNDIS_QUERY_MSG
:
1040 return rndis_query_response(s
, (rndis_query_msg_type
*) data
, length
);
1043 return rndis_set_response(s
, (rndis_set_msg_type
*) data
, length
);
1045 case RNDIS_RESET_MSG
:
1046 rndis_clear_responsequeue(s
);
1048 usb_net_reset_in_buf(s
);
1049 return rndis_reset_response(s
, (rndis_reset_msg_type
*) data
);
1051 case RNDIS_KEEPALIVE_MSG
:
1052 /* For USB: host does this every 5 seconds */
1053 return rndis_keepalive_response(s
, (rndis_keepalive_msg_type
*) data
);
1056 return USB_RET_STALL
;
1059 static void usb_net_handle_reset(USBDevice
*dev
)
1063 static void usb_net_handle_control(USBDevice
*dev
, USBPacket
*p
,
1064 int request
, int value
, int index
, int length
, uint8_t *data
)
1066 USBNetState
*s
= (USBNetState
*) dev
;
1069 ret
= usb_desc_handle_control(dev
, p
, request
, value
, index
, length
, data
);
1075 case ClassInterfaceOutRequest
| USB_CDC_SEND_ENCAPSULATED_COMMAND
:
1076 if (!is_rndis(s
) || value
|| index
!= 0) {
1079 #ifdef TRAFFIC_DEBUG
1082 fprintf(stderr
, "SEND_ENCAPSULATED_COMMAND:");
1083 for (i
= 0; i
< length
; i
++) {
1085 fprintf(stderr
, "\n%04x:", i
);
1086 fprintf(stderr
, " %02x", data
[i
]);
1088 fprintf(stderr
, "\n\n");
1091 ret
= rndis_parse(s
, data
, length
);
1097 case ClassInterfaceRequest
| USB_CDC_GET_ENCAPSULATED_RESPONSE
:
1098 if (!is_rndis(s
) || value
|| index
!= 0) {
1101 p
->actual_length
= rndis_get_response(s
, data
);
1102 if (p
->actual_length
== 0) {
1104 p
->actual_length
= 1;
1106 #ifdef TRAFFIC_DEBUG
1109 fprintf(stderr
, "GET_ENCAPSULATED_RESPONSE:");
1110 for (i
= 0; i
< p
->actual_length
; i
++) {
1112 fprintf(stderr
, "\n%04x:", i
);
1113 fprintf(stderr
, " %02x", data
[i
]);
1115 fprintf(stderr
, "\n\n");
1122 fprintf(stderr
, "usbnet: failed control transaction: "
1123 "request 0x%x value 0x%x index 0x%x length 0x%x\n",
1124 request
, value
, index
, length
);
1125 p
->status
= USB_RET_STALL
;
1130 static void usb_net_handle_statusin(USBNetState
*s
, USBPacket
*p
)
1134 if (p
->iov
.size
< 8) {
1135 p
->status
= USB_RET_STALL
;
1139 buf
[0] = cpu_to_le32(1);
1140 buf
[1] = cpu_to_le32(0);
1141 usb_packet_copy(p
, buf
, 8);
1142 if (!s
->rndis_resp
.tqh_first
) {
1143 p
->status
= USB_RET_NAK
;
1146 #ifdef TRAFFIC_DEBUG
1147 fprintf(stderr
, "usbnet: interrupt poll len %zu return %d",
1148 p
->iov
.size
, p
->status
);
1149 iov_hexdump(p
->iov
.iov
, p
->iov
.niov
, stderr
, "usbnet", p
->status
);
1153 static void usb_net_handle_datain(USBNetState
*s
, USBPacket
*p
)
1157 if (s
->in_ptr
> s
->in_len
) {
1158 usb_net_reset_in_buf(s
);
1159 p
->status
= USB_RET_NAK
;
1163 p
->status
= USB_RET_NAK
;
1166 len
= s
->in_len
- s
->in_ptr
;
1167 if (len
> p
->iov
.size
) {
1170 usb_packet_copy(p
, &s
->in_buf
[s
->in_ptr
], len
);
1172 if (s
->in_ptr
>= s
->in_len
&&
1173 (is_rndis(s
) || (s
->in_len
& (64 - 1)) || !len
)) {
1174 /* no short packet necessary */
1175 usb_net_reset_in_buf(s
);
1178 #ifdef TRAFFIC_DEBUG
1179 fprintf(stderr
, "usbnet: data in len %zu return %d", p
->iov
.size
, len
);
1180 iov_hexdump(p
->iov
.iov
, p
->iov
.niov
, stderr
, "usbnet", len
);
1184 static void usb_net_handle_dataout(USBNetState
*s
, USBPacket
*p
)
1186 int sz
= sizeof(s
->out_buf
) - s
->out_ptr
;
1187 struct rndis_packet_msg_type
*msg
=
1188 (struct rndis_packet_msg_type
*) s
->out_buf
;
1191 #ifdef TRAFFIC_DEBUG
1192 fprintf(stderr
, "usbnet: data out len %zu\n", p
->iov
.size
);
1193 iov_hexdump(p
->iov
.iov
, p
->iov
.niov
, stderr
, "usbnet", p
->iov
.size
);
1196 if (sz
> p
->iov
.size
) {
1199 usb_packet_copy(p
, &s
->out_buf
[s
->out_ptr
], sz
);
1203 if (p
->iov
.size
< 64) {
1204 qemu_send_packet(qemu_get_queue(s
->nic
), s
->out_buf
, s
->out_ptr
);
1209 len
= le32_to_cpu(msg
->MessageLength
);
1210 if (s
->out_ptr
< 8 || s
->out_ptr
< len
) {
1213 if (le32_to_cpu(msg
->MessageType
) == RNDIS_PACKET_MSG
) {
1214 uint32_t offs
= 8 + le32_to_cpu(msg
->DataOffset
);
1215 uint32_t size
= le32_to_cpu(msg
->DataLength
);
1216 if (offs
+ size
<= len
)
1217 qemu_send_packet(qemu_get_queue(s
->nic
), s
->out_buf
+ offs
, size
);
1220 memmove(s
->out_buf
, &s
->out_buf
[len
], s
->out_ptr
);
1223 static void usb_net_handle_data(USBDevice
*dev
, USBPacket
*p
)
1225 USBNetState
*s
= (USBNetState
*) dev
;
1229 switch (p
->ep
->nr
) {
1231 usb_net_handle_statusin(s
, p
);
1235 usb_net_handle_datain(s
, p
);
1244 switch (p
->ep
->nr
) {
1246 usb_net_handle_dataout(s
, p
);
1256 p
->status
= USB_RET_STALL
;
1260 if (p
->status
== USB_RET_STALL
) {
1261 fprintf(stderr
, "usbnet: failed data transaction: "
1262 "pid 0x%x ep 0x%x len 0x%zx\n",
1263 p
->pid
, p
->ep
->nr
, p
->iov
.size
);
1267 static ssize_t
usbnet_receive(NetClientState
*nc
, const uint8_t *buf
, size_t size
)
1269 USBNetState
*s
= qemu_get_nic_opaque(nc
);
1270 uint8_t *in_buf
= s
->in_buf
;
1271 size_t total_size
= size
;
1273 if (!s
->dev
.config
) {
1278 if (s
->rndis_state
!= RNDIS_DATA_INITIALIZED
) {
1281 total_size
+= sizeof(struct rndis_packet_msg_type
);
1283 if (total_size
> sizeof(s
->in_buf
)) {
1287 /* Only accept packet if input buffer is empty */
1288 if (s
->in_len
> 0) {
1293 struct rndis_packet_msg_type
*msg
;
1295 msg
= (struct rndis_packet_msg_type
*)in_buf
;
1296 memset(msg
, 0, sizeof(struct rndis_packet_msg_type
));
1297 msg
->MessageType
= cpu_to_le32(RNDIS_PACKET_MSG
);
1298 msg
->MessageLength
= cpu_to_le32(size
+ sizeof(*msg
));
1299 msg
->DataOffset
= cpu_to_le32(sizeof(*msg
) - 8);
1300 msg
->DataLength
= cpu_to_le32(size
);
1301 /* msg->OOBDataOffset;
1302 * msg->OOBDataLength;
1303 * msg->NumOOBDataElements;
1304 * msg->PerPacketInfoOffset;
1305 * msg->PerPacketInfoLength;
1309 in_buf
+= sizeof(*msg
);
1312 memcpy(in_buf
, buf
, size
);
1313 s
->in_len
= total_size
;
1318 static void usbnet_cleanup(NetClientState
*nc
)
1320 USBNetState
*s
= qemu_get_nic_opaque(nc
);
1325 static void usb_net_handle_destroy(USBDevice
*dev
)
1327 USBNetState
*s
= (USBNetState
*) dev
;
1329 /* TODO: remove the nd_table[] entry */
1330 rndis_clear_responsequeue(s
);
1331 qemu_del_nic(s
->nic
);
1334 static NetClientInfo net_usbnet_info
= {
1335 .type
= NET_CLIENT_OPTIONS_KIND_NIC
,
1336 .size
= sizeof(NICState
),
1337 .receive
= usbnet_receive
,
1338 .cleanup
= usbnet_cleanup
,
1341 static void usb_net_realize(USBDevice
*dev
, Error
**errrp
)
1343 USBNetState
*s
= USB_NET(dev
);
1345 usb_desc_create_serial(dev
);
1348 s
->rndis_state
= RNDIS_UNINITIALIZED
;
1349 QTAILQ_INIT(&s
->rndis_resp
);
1351 s
->medium
= 0; /* NDIS_MEDIUM_802_3 */
1352 s
->speed
= 1000000; /* 100MBps, in 100Bps units */
1353 s
->media_state
= 0; /* NDIS_MEDIA_STATE_CONNECTED */;
1355 s
->vendorid
= 0x1234;
1356 s
->intr
= usb_ep_get(dev
, USB_TOKEN_IN
, 1);
1358 qemu_macaddr_default_if_unset(&s
->conf
.macaddr
);
1359 s
->nic
= qemu_new_nic(&net_usbnet_info
, &s
->conf
,
1360 object_get_typename(OBJECT(s
)), s
->dev
.qdev
.id
, s
);
1361 qemu_format_nic_info_str(qemu_get_queue(s
->nic
), s
->conf
.macaddr
.a
);
1362 snprintf(s
->usbstring_mac
, sizeof(s
->usbstring_mac
),
1363 "%02x%02x%02x%02x%02x%02x",
1365 s
->conf
.macaddr
.a
[1],
1366 s
->conf
.macaddr
.a
[2],
1367 s
->conf
.macaddr
.a
[3],
1368 s
->conf
.macaddr
.a
[4],
1369 s
->conf
.macaddr
.a
[5]);
1370 usb_desc_set_string(dev
, STRING_ETHADDR
, s
->usbstring_mac
);
1373 static void usb_net_instance_init(Object
*obj
)
1375 USBDevice
*dev
= USB_DEVICE(obj
);
1376 USBNetState
*s
= USB_NET(dev
);
1378 device_add_bootindex_property(obj
, &s
->conf
.bootindex
,
1379 "bootindex", "/ethernet-phy@0",
1383 static USBDevice
*usb_net_init(USBBus
*bus
, const char *cmdline
)
1385 Error
*local_err
= NULL
;
1390 opts
= qemu_opts_parse_noisily(qemu_find_opts("net"), cmdline
, false);
1394 qemu_opt_set(opts
, "type", "nic", &error_abort
);
1395 qemu_opt_set(opts
, "model", "usb", &error_abort
);
1397 idx
= net_client_init(opts
, 0, &local_err
);
1399 error_report_err(local_err
);
1403 dev
= usb_create(bus
, "usb-net");
1404 qdev_set_nic_properties(&dev
->qdev
, &nd_table
[idx
]);
1408 static const VMStateDescription vmstate_usb_net
= {
1413 static Property net_properties
[] = {
1414 DEFINE_NIC_PROPERTIES(USBNetState
, conf
),
1415 DEFINE_PROP_END_OF_LIST(),
1418 static void usb_net_class_initfn(ObjectClass
*klass
, void *data
)
1420 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1421 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
1423 uc
->realize
= usb_net_realize
;
1424 uc
->product_desc
= "QEMU USB Network Interface";
1425 uc
->usb_desc
= &desc_net
;
1426 uc
->handle_reset
= usb_net_handle_reset
;
1427 uc
->handle_control
= usb_net_handle_control
;
1428 uc
->handle_data
= usb_net_handle_data
;
1429 uc
->handle_destroy
= usb_net_handle_destroy
;
1430 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1431 dc
->fw_name
= "network";
1432 dc
->vmsd
= &vmstate_usb_net
;
1433 dc
->props
= net_properties
;
1436 static const TypeInfo net_info
= {
1437 .name
= TYPE_USB_NET
,
1438 .parent
= TYPE_USB_DEVICE
,
1439 .instance_size
= sizeof(USBNetState
),
1440 .class_init
= usb_net_class_initfn
,
1441 .instance_init
= usb_net_instance_init
,
1444 static void usb_net_register_types(void)
1446 type_register_static(&net_info
);
1447 usb_legacy_register(TYPE_USB_NET
, "net", usb_net_init
);
1450 type_init(usb_net_register_types
)