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 (buflen
> length
|| bufoffs
>= length
|| bufoffs
+ buflen
> length
) {
920 return USB_RET_STALL
;
923 infobuflen
= ndis_query(s
, le32_to_cpu(buf
->OID
),
924 bufoffs
+ (uint8_t *) buf
, buflen
, infobuf
,
926 resplen
= sizeof(rndis_query_cmplt_type
) +
927 ((infobuflen
< 0) ? 0 : infobuflen
);
928 resp
= rndis_queue_response(s
, resplen
);
930 return USB_RET_STALL
;
932 resp
->MessageType
= cpu_to_le32(RNDIS_QUERY_CMPLT
);
933 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
934 resp
->MessageLength
= cpu_to_le32(resplen
);
936 if (infobuflen
< 0) {
937 /* OID not supported */
938 resp
->Status
= cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED
);
939 resp
->InformationBufferLength
= cpu_to_le32(0);
940 resp
->InformationBufferOffset
= cpu_to_le32(0);
944 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
945 resp
->InformationBufferOffset
=
946 cpu_to_le32(infobuflen
? sizeof(rndis_query_cmplt_type
) - 8 : 0);
947 resp
->InformationBufferLength
= cpu_to_le32(infobuflen
);
948 memcpy(resp
+ 1, infobuf
, infobuflen
);
953 static int rndis_set_response(USBNetState
*s
,
954 rndis_set_msg_type
*buf
, unsigned int length
)
956 rndis_set_cmplt_type
*resp
=
957 rndis_queue_response(s
, sizeof(rndis_set_cmplt_type
));
958 uint32_t bufoffs
, buflen
;
962 return USB_RET_STALL
;
964 bufoffs
= le32_to_cpu(buf
->InformationBufferOffset
) + 8;
965 buflen
= le32_to_cpu(buf
->InformationBufferLength
);
966 if (buflen
> length
|| bufoffs
>= length
|| bufoffs
+ buflen
> length
) {
967 return USB_RET_STALL
;
970 ret
= ndis_set(s
, le32_to_cpu(buf
->OID
),
971 bufoffs
+ (uint8_t *) buf
, buflen
);
972 resp
->MessageType
= cpu_to_le32(RNDIS_SET_CMPLT
);
973 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
974 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_set_cmplt_type
));
976 /* OID not supported */
977 resp
->Status
= cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED
);
980 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
985 static int rndis_reset_response(USBNetState
*s
, rndis_reset_msg_type
*buf
)
987 rndis_reset_cmplt_type
*resp
=
988 rndis_queue_response(s
, sizeof(rndis_reset_cmplt_type
));
991 return USB_RET_STALL
;
993 resp
->MessageType
= cpu_to_le32(RNDIS_RESET_CMPLT
);
994 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_reset_cmplt_type
));
995 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
996 resp
->AddressingReset
= cpu_to_le32(1); /* reset information */
1001 static int rndis_keepalive_response(USBNetState
*s
,
1002 rndis_keepalive_msg_type
*buf
)
1004 rndis_keepalive_cmplt_type
*resp
=
1005 rndis_queue_response(s
, sizeof(rndis_keepalive_cmplt_type
));
1008 return USB_RET_STALL
;
1010 resp
->MessageType
= cpu_to_le32(RNDIS_KEEPALIVE_CMPLT
);
1011 resp
->MessageLength
= cpu_to_le32(sizeof(rndis_keepalive_cmplt_type
));
1012 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
1013 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
1018 /* Prepare to receive the next packet */
1019 static void usb_net_reset_in_buf(USBNetState
*s
)
1021 s
->in_ptr
= s
->in_len
= 0;
1022 qemu_flush_queued_packets(qemu_get_queue(s
->nic
));
1025 static int rndis_parse(USBNetState
*s
, uint8_t *data
, int length
)
1028 le32
*tmp
= (le32
*) data
;
1030 msg_type
= le32_to_cpup(tmp
);
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_handle_destroy(USBDevice
*dev
)
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_OPTIONS_KIND_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 USBDevice
*usb_net_init(USBBus
*bus
, const char *cmdline
)
1388 Error
*local_err
= NULL
;
1393 opts
= qemu_opts_parse_noisily(qemu_find_opts("net"), cmdline
, false);
1397 qemu_opt_set(opts
, "type", "nic", &error_abort
);
1398 qemu_opt_set(opts
, "model", "usb", &error_abort
);
1400 idx
= net_client_init(opts
, 0, &local_err
);
1402 error_report_err(local_err
);
1406 dev
= usb_create(bus
, "usb-net");
1407 qdev_set_nic_properties(&dev
->qdev
, &nd_table
[idx
]);
1411 static const VMStateDescription vmstate_usb_net
= {
1416 static Property net_properties
[] = {
1417 DEFINE_NIC_PROPERTIES(USBNetState
, conf
),
1418 DEFINE_PROP_END_OF_LIST(),
1421 static void usb_net_class_initfn(ObjectClass
*klass
, void *data
)
1423 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1424 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
1426 uc
->realize
= usb_net_realize
;
1427 uc
->product_desc
= "QEMU USB Network Interface";
1428 uc
->usb_desc
= &desc_net
;
1429 uc
->handle_reset
= usb_net_handle_reset
;
1430 uc
->handle_control
= usb_net_handle_control
;
1431 uc
->handle_data
= usb_net_handle_data
;
1432 uc
->handle_destroy
= usb_net_handle_destroy
;
1433 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1434 dc
->fw_name
= "network";
1435 dc
->vmsd
= &vmstate_usb_net
;
1436 dc
->props
= net_properties
;
1439 static const TypeInfo net_info
= {
1440 .name
= TYPE_USB_NET
,
1441 .parent
= TYPE_USB_DEVICE
,
1442 .instance_size
= sizeof(USBNetState
),
1443 .class_init
= usb_net_class_initfn
,
1444 .instance_init
= usb_net_instance_init
,
1447 static void usb_net_register_types(void)
1449 type_register_static(&net_info
);
1450 usb_legacy_register(TYPE_USB_NET
, "net", usb_net_init
);
1453 type_init(usb_net_register_types
)