2008-07-17 22:47:13 +02:00
|
|
|
/*
|
|
|
|
* QEMU USB Net devices
|
|
|
|
*
|
|
|
|
* Copyright (c) 2006 Thomas Sailer
|
|
|
|
* Copyright (c) 2008 Andrzej Zaborowski
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2016-01-26 19:17:12 +01:00
|
|
|
#include "qemu/osdep.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2008-07-17 22:47:13 +02:00
|
|
|
#include "qemu-common.h"
|
2012-03-07 14:55:18 +01:00
|
|
|
#include "hw/usb.h"
|
|
|
|
#include "hw/usb/desc.h"
|
2012-10-24 08:43:34 +02:00
|
|
|
#include "net/net.h"
|
2014-09-19 08:48:25 +02:00
|
|
|
#include "qemu/error-report.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/queue.h"
|
|
|
|
#include "qemu/config-file.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/sysemu.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/iov.h"
|
2016-03-20 18:16:19 +01:00
|
|
|
#include "qemu/cutils.h"
|
2008-07-17 22:47:13 +02:00
|
|
|
|
|
|
|
/*#define TRAFFIC_DEBUG*/
|
|
|
|
/* Thanks to NetChip Technologies for donating this product ID.
|
|
|
|
* It's for devices with only CDC Ethernet configurations.
|
|
|
|
*/
|
|
|
|
#define CDC_VENDOR_NUM 0x0525 /* NetChip */
|
|
|
|
#define CDC_PRODUCT_NUM 0xa4a1 /* Linux-USB Ethernet Gadget */
|
|
|
|
/* For hardware that can talk RNDIS and either of the above protocols,
|
|
|
|
* use this ID ... the windows INF files will know it.
|
|
|
|
*/
|
|
|
|
#define RNDIS_VENDOR_NUM 0x0525 /* NetChip */
|
|
|
|
#define RNDIS_PRODUCT_NUM 0xa4a2 /* Ethernet/RNDIS Gadget */
|
|
|
|
|
|
|
|
enum usbstring_idx {
|
|
|
|
STRING_MANUFACTURER = 1,
|
|
|
|
STRING_PRODUCT,
|
|
|
|
STRING_ETHADDR,
|
|
|
|
STRING_DATA,
|
|
|
|
STRING_CONTROL,
|
|
|
|
STRING_RNDIS_CONTROL,
|
|
|
|
STRING_CDC,
|
|
|
|
STRING_SUBSET,
|
|
|
|
STRING_RNDIS,
|
|
|
|
STRING_SERIALNUMBER,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define DEV_CONFIG_VALUE 1 /* CDC or a subset */
|
|
|
|
#define DEV_RNDIS_CONFIG_VALUE 2 /* RNDIS; optional */
|
|
|
|
|
|
|
|
#define USB_CDC_SUBCLASS_ACM 0x02
|
|
|
|
#define USB_CDC_SUBCLASS_ETHERNET 0x06
|
|
|
|
|
|
|
|
#define USB_CDC_PROTO_NONE 0
|
|
|
|
#define USB_CDC_ACM_PROTO_VENDOR 0xff
|
|
|
|
|
|
|
|
#define USB_CDC_HEADER_TYPE 0x00 /* header_desc */
|
|
|
|
#define USB_CDC_CALL_MANAGEMENT_TYPE 0x01 /* call_mgmt_descriptor */
|
|
|
|
#define USB_CDC_ACM_TYPE 0x02 /* acm_descriptor */
|
|
|
|
#define USB_CDC_UNION_TYPE 0x06 /* union_desc */
|
|
|
|
#define USB_CDC_ETHERNET_TYPE 0x0f /* ether_desc */
|
|
|
|
|
|
|
|
#define USB_CDC_SEND_ENCAPSULATED_COMMAND 0x00
|
|
|
|
#define USB_CDC_GET_ENCAPSULATED_RESPONSE 0x01
|
|
|
|
#define USB_CDC_REQ_SET_LINE_CODING 0x20
|
|
|
|
#define USB_CDC_REQ_GET_LINE_CODING 0x21
|
|
|
|
#define USB_CDC_REQ_SET_CONTROL_LINE_STATE 0x22
|
|
|
|
#define USB_CDC_REQ_SEND_BREAK 0x23
|
|
|
|
#define USB_CDC_SET_ETHERNET_MULTICAST_FILTERS 0x40
|
|
|
|
#define USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER 0x41
|
|
|
|
#define USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER 0x42
|
|
|
|
#define USB_CDC_SET_ETHERNET_PACKET_FILTER 0x43
|
|
|
|
#define USB_CDC_GET_ETHERNET_STATISTIC 0x44
|
|
|
|
|
|
|
|
#define LOG2_STATUS_INTERVAL_MSEC 5 /* 1 << 5 == 32 msec */
|
|
|
|
#define STATUS_BYTECOUNT 16 /* 8 byte header + data */
|
|
|
|
|
|
|
|
#define ETH_FRAME_LEN 1514 /* Max. octets in frame sans FCS */
|
|
|
|
|
2010-11-26 10:25:06 +01:00
|
|
|
static const USBDescStrings usb_net_stringtable = {
|
|
|
|
[STRING_MANUFACTURER] = "QEMU",
|
|
|
|
[STRING_PRODUCT] = "RNDIS/QEMU USB Network Device",
|
|
|
|
[STRING_ETHADDR] = "400102030405",
|
|
|
|
[STRING_DATA] = "QEMU USB Net Data Interface",
|
|
|
|
[STRING_CONTROL] = "QEMU USB Net Control Interface",
|
|
|
|
[STRING_RNDIS_CONTROL] = "QEMU USB Net RNDIS Control Interface",
|
|
|
|
[STRING_CDC] = "QEMU USB Net CDC",
|
|
|
|
[STRING_SUBSET] = "QEMU USB Net Subset",
|
|
|
|
[STRING_RNDIS] = "QEMU USB Net RNDIS",
|
|
|
|
[STRING_SERIALNUMBER] = "1",
|
2008-07-17 22:47:13 +02:00
|
|
|
};
|
|
|
|
|
2010-11-26 10:25:06 +01:00
|
|
|
static const USBDescIface desc_iface_rndis[] = {
|
|
|
|
{
|
|
|
|
/* RNDIS Control Interface */
|
|
|
|
.bInterfaceNumber = 0,
|
|
|
|
.bNumEndpoints = 1,
|
|
|
|
.bInterfaceClass = USB_CLASS_COMM,
|
|
|
|
.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
|
|
|
|
.bInterfaceProtocol = USB_CDC_ACM_PROTO_VENDOR,
|
|
|
|
.iInterface = STRING_RNDIS_CONTROL,
|
|
|
|
.ndesc = 4,
|
|
|
|
.descs = (USBDescOther[]) {
|
|
|
|
{
|
|
|
|
/* Header Descriptor */
|
|
|
|
.data = (uint8_t[]) {
|
|
|
|
0x05, /* u8 bLength */
|
|
|
|
USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
|
|
|
|
USB_CDC_HEADER_TYPE, /* u8 bDescriptorSubType */
|
|
|
|
0x10, 0x01, /* le16 bcdCDC */
|
|
|
|
},
|
|
|
|
},{
|
|
|
|
/* Call Management Descriptor */
|
|
|
|
.data = (uint8_t[]) {
|
|
|
|
0x05, /* u8 bLength */
|
|
|
|
USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
|
|
|
|
USB_CDC_CALL_MANAGEMENT_TYPE, /* u8 bDescriptorSubType */
|
|
|
|
0x00, /* u8 bmCapabilities */
|
|
|
|
0x01, /* u8 bDataInterface */
|
|
|
|
},
|
|
|
|
},{
|
|
|
|
/* ACM Descriptor */
|
|
|
|
.data = (uint8_t[]) {
|
|
|
|
0x04, /* u8 bLength */
|
|
|
|
USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
|
|
|
|
USB_CDC_ACM_TYPE, /* u8 bDescriptorSubType */
|
|
|
|
0x00, /* u8 bmCapabilities */
|
|
|
|
},
|
|
|
|
},{
|
|
|
|
/* Union Descriptor */
|
|
|
|
.data = (uint8_t[]) {
|
|
|
|
0x05, /* u8 bLength */
|
|
|
|
USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
|
|
|
|
USB_CDC_UNION_TYPE, /* u8 bDescriptorSubType */
|
|
|
|
0x00, /* u8 bMasterInterface0 */
|
|
|
|
0x01, /* u8 bSlaveInterface0 */
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
.eps = (USBDescEndpoint[]) {
|
|
|
|
{
|
|
|
|
.bEndpointAddress = USB_DIR_IN | 0x01,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_INT,
|
|
|
|
.wMaxPacketSize = STATUS_BYTECOUNT,
|
|
|
|
.bInterval = 1 << LOG2_STATUS_INTERVAL_MSEC,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
},{
|
|
|
|
/* RNDIS Data Interface */
|
|
|
|
.bInterfaceNumber = 1,
|
|
|
|
.bNumEndpoints = 2,
|
|
|
|
.bInterfaceClass = USB_CLASS_CDC_DATA,
|
|
|
|
.iInterface = STRING_DATA,
|
|
|
|
.eps = (USBDescEndpoint[]) {
|
|
|
|
{
|
|
|
|
.bEndpointAddress = USB_DIR_IN | 0x02,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
|
|
.wMaxPacketSize = 0x40,
|
|
|
|
},{
|
|
|
|
.bEndpointAddress = USB_DIR_OUT | 0x02,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
|
|
.wMaxPacketSize = 0x40,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-07-17 22:47:13 +02:00
|
|
|
};
|
|
|
|
|
2010-11-26 10:25:06 +01:00
|
|
|
static const USBDescIface desc_iface_cdc[] = {
|
|
|
|
{
|
|
|
|
/* CDC Control Interface */
|
|
|
|
.bInterfaceNumber = 0,
|
|
|
|
.bNumEndpoints = 1,
|
|
|
|
.bInterfaceClass = USB_CLASS_COMM,
|
|
|
|
.bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
|
|
|
|
.bInterfaceProtocol = USB_CDC_PROTO_NONE,
|
|
|
|
.iInterface = STRING_CONTROL,
|
|
|
|
.ndesc = 3,
|
|
|
|
.descs = (USBDescOther[]) {
|
|
|
|
{
|
|
|
|
/* Header Descriptor */
|
|
|
|
.data = (uint8_t[]) {
|
|
|
|
0x05, /* u8 bLength */
|
|
|
|
USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
|
|
|
|
USB_CDC_HEADER_TYPE, /* u8 bDescriptorSubType */
|
|
|
|
0x10, 0x01, /* le16 bcdCDC */
|
|
|
|
},
|
|
|
|
},{
|
|
|
|
/* Union Descriptor */
|
|
|
|
.data = (uint8_t[]) {
|
|
|
|
0x05, /* u8 bLength */
|
|
|
|
USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
|
|
|
|
USB_CDC_UNION_TYPE, /* u8 bDescriptorSubType */
|
|
|
|
0x00, /* u8 bMasterInterface0 */
|
|
|
|
0x01, /* u8 bSlaveInterface0 */
|
|
|
|
},
|
|
|
|
},{
|
|
|
|
/* Ethernet Descriptor */
|
|
|
|
.data = (uint8_t[]) {
|
|
|
|
0x0d, /* u8 bLength */
|
|
|
|
USB_DT_CS_INTERFACE, /* u8 bDescriptorType */
|
|
|
|
USB_CDC_ETHERNET_TYPE, /* u8 bDescriptorSubType */
|
|
|
|
STRING_ETHADDR, /* u8 iMACAddress */
|
|
|
|
0x00, 0x00, 0x00, 0x00, /* le32 bmEthernetStatistics */
|
|
|
|
ETH_FRAME_LEN & 0xff,
|
|
|
|
ETH_FRAME_LEN >> 8, /* le16 wMaxSegmentSize */
|
|
|
|
0x00, 0x00, /* le16 wNumberMCFilters */
|
|
|
|
0x00, /* u8 bNumberPowerFilters */
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
.eps = (USBDescEndpoint[]) {
|
|
|
|
{
|
|
|
|
.bEndpointAddress = USB_DIR_IN | 0x01,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_INT,
|
|
|
|
.wMaxPacketSize = STATUS_BYTECOUNT,
|
|
|
|
.bInterval = 1 << LOG2_STATUS_INTERVAL_MSEC,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
},{
|
|
|
|
/* CDC Data Interface (off) */
|
|
|
|
.bInterfaceNumber = 1,
|
|
|
|
.bAlternateSetting = 0,
|
|
|
|
.bNumEndpoints = 0,
|
|
|
|
.bInterfaceClass = USB_CLASS_CDC_DATA,
|
|
|
|
},{
|
|
|
|
/* CDC Data Interface */
|
|
|
|
.bInterfaceNumber = 1,
|
|
|
|
.bAlternateSetting = 1,
|
|
|
|
.bNumEndpoints = 2,
|
|
|
|
.bInterfaceClass = USB_CLASS_CDC_DATA,
|
|
|
|
.iInterface = STRING_DATA,
|
|
|
|
.eps = (USBDescEndpoint[]) {
|
|
|
|
{
|
|
|
|
.bEndpointAddress = USB_DIR_IN | 0x02,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
|
|
.wMaxPacketSize = 0x40,
|
|
|
|
},{
|
|
|
|
.bEndpointAddress = USB_DIR_OUT | 0x02,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
|
|
.wMaxPacketSize = 0x40,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const USBDescDevice desc_device_net = {
|
|
|
|
.bcdUSB = 0x0200,
|
|
|
|
.bDeviceClass = USB_CLASS_COMM,
|
|
|
|
.bMaxPacketSize0 = 0x40,
|
|
|
|
.bNumConfigurations = 2,
|
|
|
|
.confs = (USBDescConfig[]) {
|
|
|
|
{
|
|
|
|
.bNumInterfaces = 2,
|
|
|
|
.bConfigurationValue = DEV_RNDIS_CONFIG_VALUE,
|
|
|
|
.iConfiguration = STRING_RNDIS,
|
2013-12-16 08:42:49 +01:00
|
|
|
.bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
|
2010-11-26 10:25:06 +01:00
|
|
|
.bMaxPower = 0x32,
|
|
|
|
.nif = ARRAY_SIZE(desc_iface_rndis),
|
|
|
|
.ifs = desc_iface_rndis,
|
|
|
|
},{
|
|
|
|
.bNumInterfaces = 2,
|
|
|
|
.bConfigurationValue = DEV_CONFIG_VALUE,
|
|
|
|
.iConfiguration = STRING_CDC,
|
2013-12-16 08:42:49 +01:00
|
|
|
.bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
|
2010-11-26 10:25:06 +01:00
|
|
|
.bMaxPower = 0x32,
|
|
|
|
.nif = ARRAY_SIZE(desc_iface_cdc),
|
|
|
|
.ifs = desc_iface_cdc,
|
|
|
|
}
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const USBDesc desc_net = {
|
|
|
|
.id = {
|
|
|
|
.idVendor = RNDIS_VENDOR_NUM,
|
|
|
|
.idProduct = RNDIS_PRODUCT_NUM,
|
|
|
|
.bcdDevice = 0,
|
|
|
|
.iManufacturer = STRING_MANUFACTURER,
|
|
|
|
.iProduct = STRING_PRODUCT,
|
|
|
|
.iSerialNumber = STRING_SERIALNUMBER,
|
|
|
|
},
|
|
|
|
.full = &desc_device_net,
|
|
|
|
.str = usb_net_stringtable,
|
2008-07-17 22:47:13 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* RNDIS Definitions - in theory not specific to USB.
|
|
|
|
*/
|
|
|
|
#define RNDIS_MAXIMUM_FRAME_SIZE 1518
|
|
|
|
#define RNDIS_MAX_TOTAL_SIZE 1558
|
|
|
|
|
|
|
|
/* Remote NDIS Versions */
|
|
|
|
#define RNDIS_MAJOR_VERSION 1
|
|
|
|
#define RNDIS_MINOR_VERSION 0
|
|
|
|
|
|
|
|
/* Status Values */
|
|
|
|
#define RNDIS_STATUS_SUCCESS 0x00000000U /* Success */
|
|
|
|
#define RNDIS_STATUS_FAILURE 0xc0000001U /* Unspecified error */
|
|
|
|
#define RNDIS_STATUS_INVALID_DATA 0xc0010015U /* Invalid data */
|
|
|
|
#define RNDIS_STATUS_NOT_SUPPORTED 0xc00000bbU /* Unsupported request */
|
|
|
|
#define RNDIS_STATUS_MEDIA_CONNECT 0x4001000bU /* Device connected */
|
|
|
|
#define RNDIS_STATUS_MEDIA_DISCONNECT 0x4001000cU /* Device disconnected */
|
|
|
|
|
|
|
|
/* Message Set for Connectionless (802.3) Devices */
|
|
|
|
enum {
|
|
|
|
RNDIS_PACKET_MSG = 1,
|
|
|
|
RNDIS_INITIALIZE_MSG = 2, /* Initialize device */
|
|
|
|
RNDIS_HALT_MSG = 3,
|
|
|
|
RNDIS_QUERY_MSG = 4,
|
|
|
|
RNDIS_SET_MSG = 5,
|
|
|
|
RNDIS_RESET_MSG = 6,
|
|
|
|
RNDIS_INDICATE_STATUS_MSG = 7,
|
|
|
|
RNDIS_KEEPALIVE_MSG = 8,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Message completion */
|
|
|
|
enum {
|
|
|
|
RNDIS_INITIALIZE_CMPLT = 0x80000002U,
|
|
|
|
RNDIS_QUERY_CMPLT = 0x80000004U,
|
|
|
|
RNDIS_SET_CMPLT = 0x80000005U,
|
|
|
|
RNDIS_RESET_CMPLT = 0x80000006U,
|
|
|
|
RNDIS_KEEPALIVE_CMPLT = 0x80000008U,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Device Flags */
|
|
|
|
enum {
|
|
|
|
RNDIS_DF_CONNECTIONLESS = 1,
|
|
|
|
RNDIS_DF_CONNECTIONORIENTED = 2,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define RNDIS_MEDIUM_802_3 0x00000000U
|
|
|
|
|
|
|
|
/* from drivers/net/sk98lin/h/skgepnmi.h */
|
|
|
|
#define OID_PNP_CAPABILITIES 0xfd010100
|
|
|
|
#define OID_PNP_SET_POWER 0xfd010101
|
|
|
|
#define OID_PNP_QUERY_POWER 0xfd010102
|
|
|
|
#define OID_PNP_ADD_WAKE_UP_PATTERN 0xfd010103
|
|
|
|
#define OID_PNP_REMOVE_WAKE_UP_PATTERN 0xfd010104
|
|
|
|
#define OID_PNP_ENABLE_WAKE_UP 0xfd010106
|
|
|
|
|
|
|
|
typedef uint32_t le32;
|
|
|
|
|
|
|
|
typedef struct rndis_init_msg_type {
|
|
|
|
le32 MessageType;
|
|
|
|
le32 MessageLength;
|
|
|
|
le32 RequestID;
|
|
|
|
le32 MajorVersion;
|
|
|
|
le32 MinorVersion;
|
|
|
|
le32 MaxTransferSize;
|
|
|
|
} rndis_init_msg_type;
|
|
|
|
|
|
|
|
typedef struct rndis_init_cmplt_type {
|
|
|
|
le32 MessageType;
|
|
|
|
le32 MessageLength;
|
|
|
|
le32 RequestID;
|
|
|
|
le32 Status;
|
|
|
|
le32 MajorVersion;
|
|
|
|
le32 MinorVersion;
|
|
|
|
le32 DeviceFlags;
|
|
|
|
le32 Medium;
|
|
|
|
le32 MaxPacketsPerTransfer;
|
|
|
|
le32 MaxTransferSize;
|
|
|
|
le32 PacketAlignmentFactor;
|
|
|
|
le32 AFListOffset;
|
|
|
|
le32 AFListSize;
|
|
|
|
} rndis_init_cmplt_type;
|
|
|
|
|
|
|
|
typedef struct rndis_halt_msg_type {
|
|
|
|
le32 MessageType;
|
|
|
|
le32 MessageLength;
|
|
|
|
le32 RequestID;
|
|
|
|
} rndis_halt_msg_type;
|
|
|
|
|
|
|
|
typedef struct rndis_query_msg_type {
|
|
|
|
le32 MessageType;
|
|
|
|
le32 MessageLength;
|
|
|
|
le32 RequestID;
|
|
|
|
le32 OID;
|
|
|
|
le32 InformationBufferLength;
|
|
|
|
le32 InformationBufferOffset;
|
|
|
|
le32 DeviceVcHandle;
|
|
|
|
} rndis_query_msg_type;
|
|
|
|
|
|
|
|
typedef struct rndis_query_cmplt_type {
|
|
|
|
le32 MessageType;
|
|
|
|
le32 MessageLength;
|
|
|
|
le32 RequestID;
|
|
|
|
le32 Status;
|
|
|
|
le32 InformationBufferLength;
|
|
|
|
le32 InformationBufferOffset;
|
|
|
|
} rndis_query_cmplt_type;
|
|
|
|
|
|
|
|
typedef struct rndis_set_msg_type {
|
|
|
|
le32 MessageType;
|
|
|
|
le32 MessageLength;
|
|
|
|
le32 RequestID;
|
|
|
|
le32 OID;
|
|
|
|
le32 InformationBufferLength;
|
|
|
|
le32 InformationBufferOffset;
|
|
|
|
le32 DeviceVcHandle;
|
|
|
|
} rndis_set_msg_type;
|
|
|
|
|
|
|
|
typedef struct rndis_set_cmplt_type {
|
|
|
|
le32 MessageType;
|
|
|
|
le32 MessageLength;
|
|
|
|
le32 RequestID;
|
|
|
|
le32 Status;
|
|
|
|
} rndis_set_cmplt_type;
|
|
|
|
|
|
|
|
typedef struct rndis_reset_msg_type {
|
|
|
|
le32 MessageType;
|
|
|
|
le32 MessageLength;
|
|
|
|
le32 Reserved;
|
|
|
|
} rndis_reset_msg_type;
|
|
|
|
|
|
|
|
typedef struct rndis_reset_cmplt_type {
|
|
|
|
le32 MessageType;
|
|
|
|
le32 MessageLength;
|
|
|
|
le32 Status;
|
|
|
|
le32 AddressingReset;
|
|
|
|
} rndis_reset_cmplt_type;
|
|
|
|
|
|
|
|
typedef struct rndis_indicate_status_msg_type {
|
|
|
|
le32 MessageType;
|
|
|
|
le32 MessageLength;
|
|
|
|
le32 Status;
|
|
|
|
le32 StatusBufferLength;
|
|
|
|
le32 StatusBufferOffset;
|
|
|
|
} rndis_indicate_status_msg_type;
|
|
|
|
|
|
|
|
typedef struct rndis_keepalive_msg_type {
|
|
|
|
le32 MessageType;
|
|
|
|
le32 MessageLength;
|
|
|
|
le32 RequestID;
|
|
|
|
} rndis_keepalive_msg_type;
|
|
|
|
|
|
|
|
typedef struct rndis_keepalive_cmplt_type {
|
|
|
|
le32 MessageType;
|
|
|
|
le32 MessageLength;
|
|
|
|
le32 RequestID;
|
|
|
|
le32 Status;
|
|
|
|
} rndis_keepalive_cmplt_type;
|
|
|
|
|
|
|
|
struct rndis_packet_msg_type {
|
|
|
|
le32 MessageType;
|
|
|
|
le32 MessageLength;
|
|
|
|
le32 DataOffset;
|
|
|
|
le32 DataLength;
|
|
|
|
le32 OOBDataOffset;
|
|
|
|
le32 OOBDataLength;
|
|
|
|
le32 NumOOBDataElements;
|
|
|
|
le32 PerPacketInfoOffset;
|
|
|
|
le32 PerPacketInfoLength;
|
|
|
|
le32 VcHandle;
|
|
|
|
le32 Reserved;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct rndis_config_parameter {
|
|
|
|
le32 ParameterNameOffset;
|
|
|
|
le32 ParameterNameLength;
|
|
|
|
le32 ParameterType;
|
|
|
|
le32 ParameterValueOffset;
|
|
|
|
le32 ParameterValueLength;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* implementation specific */
|
|
|
|
enum rndis_state
|
|
|
|
{
|
|
|
|
RNDIS_UNINITIALIZED,
|
|
|
|
RNDIS_INITIALIZED,
|
|
|
|
RNDIS_DATA_INITIALIZED,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* from ndis.h */
|
|
|
|
enum ndis_oid {
|
|
|
|
/* Required Object IDs (OIDs) */
|
|
|
|
OID_GEN_SUPPORTED_LIST = 0x00010101,
|
|
|
|
OID_GEN_HARDWARE_STATUS = 0x00010102,
|
|
|
|
OID_GEN_MEDIA_SUPPORTED = 0x00010103,
|
|
|
|
OID_GEN_MEDIA_IN_USE = 0x00010104,
|
|
|
|
OID_GEN_MAXIMUM_LOOKAHEAD = 0x00010105,
|
|
|
|
OID_GEN_MAXIMUM_FRAME_SIZE = 0x00010106,
|
|
|
|
OID_GEN_LINK_SPEED = 0x00010107,
|
|
|
|
OID_GEN_TRANSMIT_BUFFER_SPACE = 0x00010108,
|
|
|
|
OID_GEN_RECEIVE_BUFFER_SPACE = 0x00010109,
|
|
|
|
OID_GEN_TRANSMIT_BLOCK_SIZE = 0x0001010a,
|
|
|
|
OID_GEN_RECEIVE_BLOCK_SIZE = 0x0001010b,
|
|
|
|
OID_GEN_VENDOR_ID = 0x0001010c,
|
|
|
|
OID_GEN_VENDOR_DESCRIPTION = 0x0001010d,
|
|
|
|
OID_GEN_CURRENT_PACKET_FILTER = 0x0001010e,
|
|
|
|
OID_GEN_CURRENT_LOOKAHEAD = 0x0001010f,
|
|
|
|
OID_GEN_DRIVER_VERSION = 0x00010110,
|
|
|
|
OID_GEN_MAXIMUM_TOTAL_SIZE = 0x00010111,
|
|
|
|
OID_GEN_PROTOCOL_OPTIONS = 0x00010112,
|
|
|
|
OID_GEN_MAC_OPTIONS = 0x00010113,
|
|
|
|
OID_GEN_MEDIA_CONNECT_STATUS = 0x00010114,
|
|
|
|
OID_GEN_MAXIMUM_SEND_PACKETS = 0x00010115,
|
|
|
|
OID_GEN_VENDOR_DRIVER_VERSION = 0x00010116,
|
|
|
|
OID_GEN_SUPPORTED_GUIDS = 0x00010117,
|
|
|
|
OID_GEN_NETWORK_LAYER_ADDRESSES = 0x00010118,
|
|
|
|
OID_GEN_TRANSPORT_HEADER_OFFSET = 0x00010119,
|
|
|
|
OID_GEN_MACHINE_NAME = 0x0001021a,
|
|
|
|
OID_GEN_RNDIS_CONFIG_PARAMETER = 0x0001021b,
|
|
|
|
OID_GEN_VLAN_ID = 0x0001021c,
|
|
|
|
|
|
|
|
/* Optional OIDs */
|
|
|
|
OID_GEN_MEDIA_CAPABILITIES = 0x00010201,
|
|
|
|
OID_GEN_PHYSICAL_MEDIUM = 0x00010202,
|
|
|
|
|
|
|
|
/* Required statistics OIDs */
|
|
|
|
OID_GEN_XMIT_OK = 0x00020101,
|
|
|
|
OID_GEN_RCV_OK = 0x00020102,
|
|
|
|
OID_GEN_XMIT_ERROR = 0x00020103,
|
|
|
|
OID_GEN_RCV_ERROR = 0x00020104,
|
|
|
|
OID_GEN_RCV_NO_BUFFER = 0x00020105,
|
|
|
|
|
|
|
|
/* Optional statistics OIDs */
|
|
|
|
OID_GEN_DIRECTED_BYTES_XMIT = 0x00020201,
|
|
|
|
OID_GEN_DIRECTED_FRAMES_XMIT = 0x00020202,
|
|
|
|
OID_GEN_MULTICAST_BYTES_XMIT = 0x00020203,
|
|
|
|
OID_GEN_MULTICAST_FRAMES_XMIT = 0x00020204,
|
|
|
|
OID_GEN_BROADCAST_BYTES_XMIT = 0x00020205,
|
|
|
|
OID_GEN_BROADCAST_FRAMES_XMIT = 0x00020206,
|
|
|
|
OID_GEN_DIRECTED_BYTES_RCV = 0x00020207,
|
|
|
|
OID_GEN_DIRECTED_FRAMES_RCV = 0x00020208,
|
|
|
|
OID_GEN_MULTICAST_BYTES_RCV = 0x00020209,
|
|
|
|
OID_GEN_MULTICAST_FRAMES_RCV = 0x0002020a,
|
|
|
|
OID_GEN_BROADCAST_BYTES_RCV = 0x0002020b,
|
|
|
|
OID_GEN_BROADCAST_FRAMES_RCV = 0x0002020c,
|
|
|
|
OID_GEN_RCV_CRC_ERROR = 0x0002020d,
|
|
|
|
OID_GEN_TRANSMIT_QUEUE_LENGTH = 0x0002020e,
|
|
|
|
OID_GEN_GET_TIME_CAPS = 0x0002020f,
|
|
|
|
OID_GEN_GET_NETCARD_TIME = 0x00020210,
|
|
|
|
OID_GEN_NETCARD_LOAD = 0x00020211,
|
|
|
|
OID_GEN_DEVICE_PROFILE = 0x00020212,
|
|
|
|
OID_GEN_INIT_TIME_MS = 0x00020213,
|
|
|
|
OID_GEN_RESET_COUNTS = 0x00020214,
|
|
|
|
OID_GEN_MEDIA_SENSE_COUNTS = 0x00020215,
|
|
|
|
OID_GEN_FRIENDLY_NAME = 0x00020216,
|
|
|
|
OID_GEN_MINIPORT_INFO = 0x00020217,
|
|
|
|
OID_GEN_RESET_VERIFY_PARAMETERS = 0x00020218,
|
|
|
|
|
|
|
|
/* IEEE 802.3 (Ethernet) OIDs */
|
|
|
|
OID_802_3_PERMANENT_ADDRESS = 0x01010101,
|
|
|
|
OID_802_3_CURRENT_ADDRESS = 0x01010102,
|
|
|
|
OID_802_3_MULTICAST_LIST = 0x01010103,
|
|
|
|
OID_802_3_MAXIMUM_LIST_SIZE = 0x01010104,
|
|
|
|
OID_802_3_MAC_OPTIONS = 0x01010105,
|
|
|
|
OID_802_3_RCV_ERROR_ALIGNMENT = 0x01020101,
|
|
|
|
OID_802_3_XMIT_ONE_COLLISION = 0x01020102,
|
|
|
|
OID_802_3_XMIT_MORE_COLLISIONS = 0x01020103,
|
|
|
|
OID_802_3_XMIT_DEFERRED = 0x01020201,
|
|
|
|
OID_802_3_XMIT_MAX_COLLISIONS = 0x01020202,
|
|
|
|
OID_802_3_RCV_OVERRUN = 0x01020203,
|
|
|
|
OID_802_3_XMIT_UNDERRUN = 0x01020204,
|
|
|
|
OID_802_3_XMIT_HEARTBEAT_FAILURE = 0x01020205,
|
|
|
|
OID_802_3_XMIT_TIMES_CRS_LOST = 0x01020206,
|
|
|
|
OID_802_3_XMIT_LATE_COLLISIONS = 0x01020207,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const uint32_t oid_supported_list[] =
|
|
|
|
{
|
|
|
|
/* the general stuff */
|
|
|
|
OID_GEN_SUPPORTED_LIST,
|
|
|
|
OID_GEN_HARDWARE_STATUS,
|
|
|
|
OID_GEN_MEDIA_SUPPORTED,
|
|
|
|
OID_GEN_MEDIA_IN_USE,
|
|
|
|
OID_GEN_MAXIMUM_FRAME_SIZE,
|
|
|
|
OID_GEN_LINK_SPEED,
|
|
|
|
OID_GEN_TRANSMIT_BLOCK_SIZE,
|
|
|
|
OID_GEN_RECEIVE_BLOCK_SIZE,
|
|
|
|
OID_GEN_VENDOR_ID,
|
|
|
|
OID_GEN_VENDOR_DESCRIPTION,
|
|
|
|
OID_GEN_VENDOR_DRIVER_VERSION,
|
|
|
|
OID_GEN_CURRENT_PACKET_FILTER,
|
|
|
|
OID_GEN_MAXIMUM_TOTAL_SIZE,
|
|
|
|
OID_GEN_MEDIA_CONNECT_STATUS,
|
|
|
|
OID_GEN_PHYSICAL_MEDIUM,
|
|
|
|
|
|
|
|
/* the statistical stuff */
|
|
|
|
OID_GEN_XMIT_OK,
|
|
|
|
OID_GEN_RCV_OK,
|
|
|
|
OID_GEN_XMIT_ERROR,
|
|
|
|
OID_GEN_RCV_ERROR,
|
|
|
|
OID_GEN_RCV_NO_BUFFER,
|
|
|
|
|
|
|
|
/* IEEE 802.3 */
|
|
|
|
/* the general stuff */
|
|
|
|
OID_802_3_PERMANENT_ADDRESS,
|
|
|
|
OID_802_3_CURRENT_ADDRESS,
|
|
|
|
OID_802_3_MULTICAST_LIST,
|
|
|
|
OID_802_3_MAC_OPTIONS,
|
|
|
|
OID_802_3_MAXIMUM_LIST_SIZE,
|
|
|
|
|
|
|
|
/* the statistical stuff */
|
|
|
|
OID_802_3_RCV_ERROR_ALIGNMENT,
|
|
|
|
OID_802_3_XMIT_ONE_COLLISION,
|
|
|
|
OID_802_3_XMIT_MORE_COLLISIONS,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA (1 << 0)
|
|
|
|
#define NDIS_MAC_OPTION_RECEIVE_SERIALIZED (1 << 1)
|
|
|
|
#define NDIS_MAC_OPTION_TRANSFERS_NOT_PEND (1 << 2)
|
|
|
|
#define NDIS_MAC_OPTION_NO_LOOPBACK (1 << 3)
|
|
|
|
#define NDIS_MAC_OPTION_FULL_DUPLEX (1 << 4)
|
|
|
|
#define NDIS_MAC_OPTION_EOTX_INDICATION (1 << 5)
|
|
|
|
#define NDIS_MAC_OPTION_8021P_PRIORITY (1 << 6)
|
|
|
|
|
|
|
|
struct rndis_response {
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_ENTRY(rndis_response) entries;
|
2008-07-17 22:47:13 +02:00
|
|
|
uint32_t length;
|
|
|
|
uint8_t buf[0];
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct USBNetState {
|
|
|
|
USBDevice dev;
|
|
|
|
|
|
|
|
enum rndis_state rndis_state;
|
|
|
|
uint32_t medium;
|
|
|
|
uint32_t speed;
|
|
|
|
uint32_t media_state;
|
|
|
|
uint16_t filter;
|
|
|
|
uint32_t vendorid;
|
|
|
|
|
|
|
|
unsigned int out_ptr;
|
|
|
|
uint8_t out_buf[2048];
|
|
|
|
|
|
|
|
unsigned int in_ptr, in_len;
|
|
|
|
uint8_t in_buf[2048];
|
|
|
|
|
2012-11-17 12:47:14 +01:00
|
|
|
USBEndpoint *intr;
|
|
|
|
|
2008-07-17 22:47:13 +02:00
|
|
|
char usbstring_mac[13];
|
2009-11-25 19:49:25 +01:00
|
|
|
NICState *nic;
|
|
|
|
NICConf conf;
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_HEAD(rndis_resp_head, rndis_response) rndis_resp;
|
2008-07-17 22:47:13 +02:00
|
|
|
} USBNetState;
|
|
|
|
|
2015-05-06 14:55:30 +02:00
|
|
|
#define TYPE_USB_NET "usb-net"
|
|
|
|
#define USB_NET(obj) OBJECT_CHECK(USBNetState, (obj), TYPE_USB_NET)
|
|
|
|
|
2010-11-26 20:20:41 +01:00
|
|
|
static int is_rndis(USBNetState *s)
|
|
|
|
{
|
2016-02-11 12:01:20 +01:00
|
|
|
return s->dev.config ?
|
|
|
|
s->dev.config->bConfigurationValue == DEV_RNDIS_CONFIG_VALUE : 0;
|
2010-11-26 20:20:41 +01:00
|
|
|
}
|
|
|
|
|
2008-07-17 22:47:13 +02:00
|
|
|
static int ndis_query(USBNetState *s, uint32_t oid,
|
2008-08-21 19:58:08 +02:00
|
|
|
uint8_t *inbuf, unsigned int inlen, uint8_t *outbuf,
|
|
|
|
size_t outlen)
|
2008-07-17 22:47:13 +02:00
|
|
|
{
|
2008-12-22 21:33:55 +01:00
|
|
|
unsigned int i;
|
2008-07-17 22:47:13 +02:00
|
|
|
|
|
|
|
switch (oid) {
|
|
|
|
/* general oids (table 4-1) */
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_SUPPORTED_LIST:
|
2016-06-10 17:37:57 +02:00
|
|
|
for (i = 0; i < ARRAY_SIZE(oid_supported_list); i++) {
|
|
|
|
stl_le_p(outbuf + (i * sizeof(le32)), oid_supported_list[i]);
|
|
|
|
}
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(oid_supported_list);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_HARDWARE_STATUS:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, 0);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_MEDIA_SUPPORTED:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, s->medium);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_MEDIA_IN_USE:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, s->medium);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_MAXIMUM_FRAME_SIZE:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, ETH_FRAME_LEN);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_LINK_SPEED:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, s->speed);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_TRANSMIT_BLOCK_SIZE:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, ETH_FRAME_LEN);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_RECEIVE_BLOCK_SIZE:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, ETH_FRAME_LEN);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_VENDOR_ID:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, s->vendorid);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_VENDOR_DESCRIPTION:
|
2008-09-20 10:07:15 +02:00
|
|
|
pstrcpy((char *)outbuf, outlen, "QEMU USB RNDIS Net");
|
|
|
|
return strlen((char *)outbuf) + 1;
|
2008-07-17 22:47:13 +02:00
|
|
|
|
|
|
|
case OID_GEN_VENDOR_DRIVER_VERSION:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, 1);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_CURRENT_PACKET_FILTER:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, s->filter);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_MAXIMUM_TOTAL_SIZE:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, RNDIS_MAX_TOTAL_SIZE);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_MEDIA_CONNECT_STATUS:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, s->media_state);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
case OID_GEN_PHYSICAL_MEDIUM:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, 0);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
case OID_GEN_MAC_OPTIONS:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, NDIS_MAC_OPTION_RECEIVE_SERIALIZED |
|
|
|
|
NDIS_MAC_OPTION_FULL_DUPLEX);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* statistics OIDs (table 4-2) */
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_XMIT_OK:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, 0);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_RCV_OK:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, 0);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_XMIT_ERROR:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, 0);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_RCV_ERROR:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, 0);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_GEN_RCV_NO_BUFFER:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, 0);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* ieee802.3 OIDs (table 4-3) */
|
|
|
|
/* mandatory */
|
|
|
|
case OID_802_3_PERMANENT_ADDRESS:
|
2009-11-25 19:49:25 +01:00
|
|
|
memcpy(outbuf, s->conf.macaddr.a, 6);
|
2008-07-17 22:47:13 +02:00
|
|
|
return 6;
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_802_3_CURRENT_ADDRESS:
|
2009-11-25 19:49:25 +01:00
|
|
|
memcpy(outbuf, s->conf.macaddr.a, 6);
|
2008-07-17 22:47:13 +02:00
|
|
|
return 6;
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_802_3_MULTICAST_LIST:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, 0xe0000000);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_802_3_MAXIMUM_LIST_SIZE:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, 1);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
case OID_802_3_MAC_OPTIONS:
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* ieee802.3 statistics OIDs (table 4-4) */
|
|
|
|
/* mandatory */
|
|
|
|
case OID_802_3_RCV_ERROR_ALIGNMENT:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, 0);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_802_3_XMIT_ONE_COLLISION:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, 0);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
/* mandatory */
|
|
|
|
case OID_802_3_XMIT_MORE_COLLISIONS:
|
2016-06-10 17:37:57 +02:00
|
|
|
stl_le_p(outbuf, 0);
|
2008-07-17 22:47:13 +02:00
|
|
|
return sizeof(le32);
|
|
|
|
|
|
|
|
default:
|
|
|
|
fprintf(stderr, "usbnet: unknown OID 0x%08x\n", oid);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ndis_set(USBNetState *s, uint32_t oid,
|
|
|
|
uint8_t *inbuf, unsigned int inlen)
|
|
|
|
{
|
|
|
|
switch (oid) {
|
|
|
|
case OID_GEN_CURRENT_PACKET_FILTER:
|
2016-06-10 17:37:57 +02:00
|
|
|
s->filter = ldl_le_p(inbuf);
|
2008-07-17 22:47:13 +02:00
|
|
|
if (s->filter) {
|
|
|
|
s->rndis_state = RNDIS_DATA_INITIALIZED;
|
|
|
|
} else {
|
|
|
|
s->rndis_state = RNDIS_INITIALIZED;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case OID_802_3_MULTICAST_LIST:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rndis_get_response(USBNetState *s, uint8_t *buf)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct rndis_response *r = s->rndis_resp.tqh_first;
|
|
|
|
|
|
|
|
if (!r)
|
|
|
|
return ret;
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_REMOVE(&s->rndis_resp, r, entries);
|
2008-07-17 22:47:13 +02:00
|
|
|
ret = r->length;
|
|
|
|
memcpy(buf, r->buf, r->length);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(r);
|
2008-07-17 22:47:13 +02:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *rndis_queue_response(USBNetState *s, unsigned int length)
|
|
|
|
{
|
|
|
|
struct rndis_response *r =
|
2011-08-21 05:09:37 +02:00
|
|
|
g_malloc0(sizeof(struct rndis_response) + length);
|
2008-07-17 22:47:13 +02:00
|
|
|
|
2012-11-17 12:47:14 +01:00
|
|
|
if (QTAILQ_EMPTY(&s->rndis_resp)) {
|
2013-01-29 12:44:35 +01:00
|
|
|
usb_wakeup(s->intr, 0);
|
2012-11-17 12:47:14 +01:00
|
|
|
}
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_INSERT_TAIL(&s->rndis_resp, r, entries);
|
2008-07-17 22:47:13 +02:00
|
|
|
r->length = length;
|
|
|
|
|
|
|
|
return &r->buf[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rndis_clear_responsequeue(USBNetState *s)
|
|
|
|
{
|
|
|
|
struct rndis_response *r;
|
|
|
|
|
|
|
|
while ((r = s->rndis_resp.tqh_first)) {
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_REMOVE(&s->rndis_resp, r, entries);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(r);
|
2008-07-17 22:47:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rndis_init_response(USBNetState *s, rndis_init_msg_type *buf)
|
|
|
|
{
|
|
|
|
rndis_init_cmplt_type *resp =
|
|
|
|
rndis_queue_response(s, sizeof(rndis_init_cmplt_type));
|
|
|
|
|
|
|
|
if (!resp)
|
|
|
|
return USB_RET_STALL;
|
|
|
|
|
|
|
|
resp->MessageType = cpu_to_le32(RNDIS_INITIALIZE_CMPLT);
|
|
|
|
resp->MessageLength = cpu_to_le32(sizeof(rndis_init_cmplt_type));
|
|
|
|
resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
|
|
|
|
resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
|
|
|
|
resp->MajorVersion = cpu_to_le32(RNDIS_MAJOR_VERSION);
|
|
|
|
resp->MinorVersion = cpu_to_le32(RNDIS_MINOR_VERSION);
|
|
|
|
resp->DeviceFlags = cpu_to_le32(RNDIS_DF_CONNECTIONLESS);
|
|
|
|
resp->Medium = cpu_to_le32(RNDIS_MEDIUM_802_3);
|
|
|
|
resp->MaxPacketsPerTransfer = cpu_to_le32(1);
|
|
|
|
resp->MaxTransferSize = cpu_to_le32(ETH_FRAME_LEN +
|
|
|
|
sizeof(struct rndis_packet_msg_type) + 22);
|
|
|
|
resp->PacketAlignmentFactor = cpu_to_le32(0);
|
|
|
|
resp->AFListOffset = cpu_to_le32(0);
|
|
|
|
resp->AFListSize = cpu_to_le32(0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rndis_query_response(USBNetState *s,
|
|
|
|
rndis_query_msg_type *buf, unsigned int length)
|
|
|
|
{
|
|
|
|
rndis_query_cmplt_type *resp;
|
|
|
|
/* oid_supported_list is the largest data reply */
|
|
|
|
uint8_t infobuf[sizeof(oid_supported_list)];
|
|
|
|
uint32_t bufoffs, buflen;
|
|
|
|
int infobuflen;
|
|
|
|
unsigned int resplen;
|
|
|
|
|
|
|
|
bufoffs = le32_to_cpu(buf->InformationBufferOffset) + 8;
|
|
|
|
buflen = le32_to_cpu(buf->InformationBufferLength);
|
2016-02-16 19:53:41 +01:00
|
|
|
if (buflen > length || bufoffs >= length || bufoffs + buflen > length) {
|
2008-07-17 22:47:13 +02:00
|
|
|
return USB_RET_STALL;
|
2016-02-16 19:53:41 +01:00
|
|
|
}
|
2008-07-17 22:47:13 +02:00
|
|
|
|
|
|
|
infobuflen = ndis_query(s, le32_to_cpu(buf->OID),
|
2008-08-21 19:58:08 +02:00
|
|
|
bufoffs + (uint8_t *) buf, buflen, infobuf,
|
|
|
|
sizeof(infobuf));
|
2008-07-17 22:47:13 +02:00
|
|
|
resplen = sizeof(rndis_query_cmplt_type) +
|
|
|
|
((infobuflen < 0) ? 0 : infobuflen);
|
|
|
|
resp = rndis_queue_response(s, resplen);
|
|
|
|
if (!resp)
|
|
|
|
return USB_RET_STALL;
|
|
|
|
|
|
|
|
resp->MessageType = cpu_to_le32(RNDIS_QUERY_CMPLT);
|
|
|
|
resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
|
|
|
|
resp->MessageLength = cpu_to_le32(resplen);
|
|
|
|
|
|
|
|
if (infobuflen < 0) {
|
|
|
|
/* OID not supported */
|
|
|
|
resp->Status = cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED);
|
|
|
|
resp->InformationBufferLength = cpu_to_le32(0);
|
|
|
|
resp->InformationBufferOffset = cpu_to_le32(0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
|
|
|
|
resp->InformationBufferOffset =
|
|
|
|
cpu_to_le32(infobuflen ? sizeof(rndis_query_cmplt_type) - 8 : 0);
|
|
|
|
resp->InformationBufferLength = cpu_to_le32(infobuflen);
|
|
|
|
memcpy(resp + 1, infobuf, infobuflen);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rndis_set_response(USBNetState *s,
|
|
|
|
rndis_set_msg_type *buf, unsigned int length)
|
|
|
|
{
|
|
|
|
rndis_set_cmplt_type *resp =
|
|
|
|
rndis_queue_response(s, sizeof(rndis_set_cmplt_type));
|
|
|
|
uint32_t bufoffs, buflen;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!resp)
|
|
|
|
return USB_RET_STALL;
|
|
|
|
|
|
|
|
bufoffs = le32_to_cpu(buf->InformationBufferOffset) + 8;
|
|
|
|
buflen = le32_to_cpu(buf->InformationBufferLength);
|
2016-02-16 19:53:41 +01:00
|
|
|
if (buflen > length || bufoffs >= length || bufoffs + buflen > length) {
|
2008-07-17 22:47:13 +02:00
|
|
|
return USB_RET_STALL;
|
2016-02-16 19:53:41 +01:00
|
|
|
}
|
2008-07-17 22:47:13 +02:00
|
|
|
|
|
|
|
ret = ndis_set(s, le32_to_cpu(buf->OID),
|
|
|
|
bufoffs + (uint8_t *) buf, buflen);
|
|
|
|
resp->MessageType = cpu_to_le32(RNDIS_SET_CMPLT);
|
|
|
|
resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
|
|
|
|
resp->MessageLength = cpu_to_le32(sizeof(rndis_set_cmplt_type));
|
|
|
|
if (ret < 0) {
|
|
|
|
/* OID not supported */
|
|
|
|
resp->Status = cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rndis_reset_response(USBNetState *s, rndis_reset_msg_type *buf)
|
|
|
|
{
|
|
|
|
rndis_reset_cmplt_type *resp =
|
|
|
|
rndis_queue_response(s, sizeof(rndis_reset_cmplt_type));
|
|
|
|
|
|
|
|
if (!resp)
|
|
|
|
return USB_RET_STALL;
|
|
|
|
|
|
|
|
resp->MessageType = cpu_to_le32(RNDIS_RESET_CMPLT);
|
|
|
|
resp->MessageLength = cpu_to_le32(sizeof(rndis_reset_cmplt_type));
|
|
|
|
resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
|
|
|
|
resp->AddressingReset = cpu_to_le32(1); /* reset information */
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rndis_keepalive_response(USBNetState *s,
|
|
|
|
rndis_keepalive_msg_type *buf)
|
|
|
|
{
|
|
|
|
rndis_keepalive_cmplt_type *resp =
|
|
|
|
rndis_queue_response(s, sizeof(rndis_keepalive_cmplt_type));
|
|
|
|
|
|
|
|
if (!resp)
|
|
|
|
return USB_RET_STALL;
|
|
|
|
|
|
|
|
resp->MessageType = cpu_to_le32(RNDIS_KEEPALIVE_CMPLT);
|
|
|
|
resp->MessageLength = cpu_to_le32(sizeof(rndis_keepalive_cmplt_type));
|
|
|
|
resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
|
|
|
|
resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-24 14:37:29 +02:00
|
|
|
/* Prepare to receive the next packet */
|
|
|
|
static void usb_net_reset_in_buf(USBNetState *s)
|
|
|
|
{
|
|
|
|
s->in_ptr = s->in_len = 0;
|
2013-01-30 12:12:22 +01:00
|
|
|
qemu_flush_queued_packets(qemu_get_queue(s->nic));
|
2012-08-24 14:37:29 +02:00
|
|
|
}
|
|
|
|
|
2008-07-17 22:47:13 +02:00
|
|
|
static int rndis_parse(USBNetState *s, uint8_t *data, int length)
|
|
|
|
{
|
2016-06-10 17:37:57 +02:00
|
|
|
uint32_t msg_type = ldl_le_p(data);
|
2008-07-17 22:47:13 +02:00
|
|
|
|
|
|
|
switch (msg_type) {
|
|
|
|
case RNDIS_INITIALIZE_MSG:
|
|
|
|
s->rndis_state = RNDIS_INITIALIZED;
|
|
|
|
return rndis_init_response(s, (rndis_init_msg_type *) data);
|
|
|
|
|
|
|
|
case RNDIS_HALT_MSG:
|
|
|
|
s->rndis_state = RNDIS_UNINITIALIZED;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case RNDIS_QUERY_MSG:
|
|
|
|
return rndis_query_response(s, (rndis_query_msg_type *) data, length);
|
|
|
|
|
|
|
|
case RNDIS_SET_MSG:
|
|
|
|
return rndis_set_response(s, (rndis_set_msg_type *) data, length);
|
|
|
|
|
|
|
|
case RNDIS_RESET_MSG:
|
|
|
|
rndis_clear_responsequeue(s);
|
2012-08-24 14:37:29 +02:00
|
|
|
s->out_ptr = 0;
|
|
|
|
usb_net_reset_in_buf(s);
|
2008-07-17 22:47:13 +02:00
|
|
|
return rndis_reset_response(s, (rndis_reset_msg_type *) data);
|
|
|
|
|
|
|
|
case RNDIS_KEEPALIVE_MSG:
|
|
|
|
/* For USB: host does this every 5 seconds */
|
|
|
|
return rndis_keepalive_response(s, (rndis_keepalive_msg_type *) data);
|
|
|
|
}
|
|
|
|
|
|
|
|
return USB_RET_STALL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void usb_net_handle_reset(USBDevice *dev)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
static void usb_net_handle_control(USBDevice *dev, USBPacket *p,
|
2011-02-02 16:33:13 +01:00
|
|
|
int request, int value, int index, int length, uint8_t *data)
|
2008-07-17 22:47:13 +02:00
|
|
|
{
|
|
|
|
USBNetState *s = (USBNetState *) dev;
|
2010-11-26 10:25:06 +01:00
|
|
|
int ret;
|
2008-07-17 22:47:13 +02:00
|
|
|
|
2011-02-02 16:33:13 +01:00
|
|
|
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
|
2010-11-26 10:25:06 +01:00
|
|
|
if (ret >= 0) {
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
return;
|
2010-11-26 10:25:06 +01:00
|
|
|
}
|
|
|
|
|
2008-07-17 22:47:13 +02:00
|
|
|
switch(request) {
|
|
|
|
case ClassInterfaceOutRequest | USB_CDC_SEND_ENCAPSULATED_COMMAND:
|
2010-11-26 20:20:41 +01:00
|
|
|
if (!is_rndis(s) || value || index != 0) {
|
2008-07-17 22:47:13 +02:00
|
|
|
goto fail;
|
2010-11-26 20:20:41 +01:00
|
|
|
}
|
2008-09-06 19:47:39 +02:00
|
|
|
#ifdef TRAFFIC_DEBUG
|
2008-07-17 22:47:13 +02:00
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
fprintf(stderr, "SEND_ENCAPSULATED_COMMAND:");
|
|
|
|
for (i = 0; i < length; i++) {
|
|
|
|
if (!(i & 15))
|
|
|
|
fprintf(stderr, "\n%04x:", i);
|
|
|
|
fprintf(stderr, " %02x", data[i]);
|
|
|
|
}
|
|
|
|
fprintf(stderr, "\n\n");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
ret = rndis_parse(s, data, length);
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
if (ret < 0) {
|
|
|
|
p->status = ret;
|
|
|
|
}
|
2008-07-17 22:47:13 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ClassInterfaceRequest | USB_CDC_GET_ENCAPSULATED_RESPONSE:
|
2010-11-26 20:20:41 +01:00
|
|
|
if (!is_rndis(s) || value || index != 0) {
|
2008-07-17 22:47:13 +02:00
|
|
|
goto fail;
|
2010-11-26 20:20:41 +01:00
|
|
|
}
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->actual_length = rndis_get_response(s, data);
|
|
|
|
if (p->actual_length == 0) {
|
2008-07-17 22:47:13 +02:00
|
|
|
data[0] = 0;
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->actual_length = 1;
|
2008-07-17 22:47:13 +02:00
|
|
|
}
|
2008-09-06 19:47:39 +02:00
|
|
|
#ifdef TRAFFIC_DEBUG
|
2008-07-17 22:47:13 +02:00
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
fprintf(stderr, "GET_ENCAPSULATED_RESPONSE:");
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
for (i = 0; i < p->actual_length; i++) {
|
2008-07-17 22:47:13 +02:00
|
|
|
if (!(i & 15))
|
|
|
|
fprintf(stderr, "\n%04x:", i);
|
|
|
|
fprintf(stderr, " %02x", data[i]);
|
|
|
|
}
|
|
|
|
fprintf(stderr, "\n\n");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
fail:
|
|
|
|
fprintf(stderr, "usbnet: failed control transaction: "
|
|
|
|
"request 0x%x value 0x%x index 0x%x length 0x%x\n",
|
|
|
|
request, value, index, length);
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->status = USB_RET_STALL;
|
2008-07-17 22:47:13 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
static void usb_net_handle_statusin(USBNetState *s, USBPacket *p)
|
2008-07-17 22:47:13 +02:00
|
|
|
{
|
2011-07-12 15:22:25 +02:00
|
|
|
le32 buf[2];
|
2008-07-17 22:47:13 +02:00
|
|
|
|
2011-07-12 15:22:25 +02:00
|
|
|
if (p->iov.size < 8) {
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->status = USB_RET_STALL;
|
|
|
|
return;
|
2011-07-12 15:22:25 +02:00
|
|
|
}
|
2008-07-17 22:47:13 +02:00
|
|
|
|
2011-07-12 15:22:25 +02:00
|
|
|
buf[0] = cpu_to_le32(1);
|
|
|
|
buf[1] = cpu_to_le32(0);
|
|
|
|
usb_packet_copy(p, buf, 8);
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
if (!s->rndis_resp.tqh_first) {
|
|
|
|
p->status = USB_RET_NAK;
|
|
|
|
}
|
2008-07-17 22:47:13 +02:00
|
|
|
|
2008-09-06 19:47:39 +02:00
|
|
|
#ifdef TRAFFIC_DEBUG
|
2011-07-12 15:22:25 +02:00
|
|
|
fprintf(stderr, "usbnet: interrupt poll len %zu return %d",
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->iov.size, p->status);
|
|
|
|
iov_hexdump(p->iov.iov, p->iov.niov, stderr, "usbnet", p->status);
|
2008-07-17 22:47:13 +02:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
static void usb_net_handle_datain(USBNetState *s, USBPacket *p)
|
2008-07-17 22:47:13 +02:00
|
|
|
{
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
int len;
|
2008-07-17 22:47:13 +02:00
|
|
|
|
|
|
|
if (s->in_ptr > s->in_len) {
|
2012-08-24 14:37:29 +02:00
|
|
|
usb_net_reset_in_buf(s);
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->status = USB_RET_NAK;
|
|
|
|
return;
|
2008-07-17 22:47:13 +02:00
|
|
|
}
|
|
|
|
if (!s->in_len) {
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->status = USB_RET_NAK;
|
|
|
|
return;
|
2008-07-17 22:47:13 +02:00
|
|
|
}
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
len = s->in_len - s->in_ptr;
|
|
|
|
if (len > p->iov.size) {
|
|
|
|
len = p->iov.size;
|
2011-07-12 15:22:25 +02:00
|
|
|
}
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
usb_packet_copy(p, &s->in_buf[s->in_ptr], len);
|
|
|
|
s->in_ptr += len;
|
2008-07-17 22:47:13 +02:00
|
|
|
if (s->in_ptr >= s->in_len &&
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
(is_rndis(s) || (s->in_len & (64 - 1)) || !len)) {
|
2008-07-17 22:47:13 +02:00
|
|
|
/* no short packet necessary */
|
2012-08-24 14:37:29 +02:00
|
|
|
usb_net_reset_in_buf(s);
|
2008-07-17 22:47:13 +02:00
|
|
|
}
|
|
|
|
|
2008-09-06 19:47:39 +02:00
|
|
|
#ifdef TRAFFIC_DEBUG
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
fprintf(stderr, "usbnet: data in len %zu return %d", p->iov.size, len);
|
|
|
|
iov_hexdump(p->iov.iov, p->iov.niov, stderr, "usbnet", len);
|
2008-07-17 22:47:13 +02:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
static void usb_net_handle_dataout(USBNetState *s, USBPacket *p)
|
2008-07-17 22:47:13 +02:00
|
|
|
{
|
|
|
|
int sz = sizeof(s->out_buf) - s->out_ptr;
|
|
|
|
struct rndis_packet_msg_type *msg =
|
|
|
|
(struct rndis_packet_msg_type *) s->out_buf;
|
|
|
|
uint32_t len;
|
|
|
|
|
2008-09-06 19:47:39 +02:00
|
|
|
#ifdef TRAFFIC_DEBUG
|
2011-07-12 15:22:25 +02:00
|
|
|
fprintf(stderr, "usbnet: data out len %zu\n", p->iov.size);
|
|
|
|
iov_hexdump(p->iov.iov, p->iov.niov, stderr, "usbnet", p->iov.size);
|
2008-07-17 22:47:13 +02:00
|
|
|
#endif
|
|
|
|
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
if (sz > p->iov.size) {
|
|
|
|
sz = p->iov.size;
|
|
|
|
}
|
2011-07-12 15:22:25 +02:00
|
|
|
usb_packet_copy(p, &s->out_buf[s->out_ptr], sz);
|
2008-07-17 22:47:13 +02:00
|
|
|
s->out_ptr += sz;
|
|
|
|
|
2010-11-26 20:20:41 +01:00
|
|
|
if (!is_rndis(s)) {
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
if (p->iov.size < 64) {
|
2013-01-30 12:12:22 +01:00
|
|
|
qemu_send_packet(qemu_get_queue(s->nic), s->out_buf, s->out_ptr);
|
2008-07-17 22:47:13 +02:00
|
|
|
s->out_ptr = 0;
|
|
|
|
}
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
return;
|
2008-07-17 22:47:13 +02:00
|
|
|
}
|
|
|
|
len = le32_to_cpu(msg->MessageLength);
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
if (s->out_ptr < 8 || s->out_ptr < len) {
|
|
|
|
return;
|
|
|
|
}
|
2008-07-17 22:47:13 +02:00
|
|
|
if (le32_to_cpu(msg->MessageType) == RNDIS_PACKET_MSG) {
|
|
|
|
uint32_t offs = 8 + le32_to_cpu(msg->DataOffset);
|
|
|
|
uint32_t size = le32_to_cpu(msg->DataLength);
|
2016-02-16 19:53:41 +01:00
|
|
|
if (offs < len && size < len && offs + size <= len) {
|
2013-01-30 12:12:22 +01:00
|
|
|
qemu_send_packet(qemu_get_queue(s->nic), s->out_buf + offs, size);
|
2016-02-16 19:53:41 +01:00
|
|
|
}
|
2008-07-17 22:47:13 +02:00
|
|
|
}
|
|
|
|
s->out_ptr -= len;
|
|
|
|
memmove(s->out_buf, &s->out_buf[len], s->out_ptr);
|
|
|
|
}
|
|
|
|
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
static void usb_net_handle_data(USBDevice *dev, USBPacket *p)
|
2008-07-17 22:47:13 +02:00
|
|
|
{
|
|
|
|
USBNetState *s = (USBNetState *) dev;
|
|
|
|
|
|
|
|
switch(p->pid) {
|
|
|
|
case USB_TOKEN_IN:
|
2012-01-12 13:23:01 +01:00
|
|
|
switch (p->ep->nr) {
|
2008-07-17 22:47:13 +02:00
|
|
|
case 1:
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
usb_net_handle_statusin(s, p);
|
2008-07-17 22:47:13 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
usb_net_handle_datain(s, p);
|
2008-07-17 22:47:13 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case USB_TOKEN_OUT:
|
2012-01-12 13:23:01 +01:00
|
|
|
switch (p->ep->nr) {
|
2008-07-17 22:47:13 +02:00
|
|
|
case 2:
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
usb_net_handle_dataout(s, p);
|
2008-07-17 22:47:13 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
fail:
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
p->status = USB_RET_STALL;
|
2008-07-17 22:47:13 +02:00
|
|
|
break;
|
|
|
|
}
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
|
|
|
|
if (p->status == USB_RET_STALL) {
|
2008-07-17 22:47:13 +02:00
|
|
|
fprintf(stderr, "usbnet: failed data transaction: "
|
2011-07-12 15:22:25 +02:00
|
|
|
"pid 0x%x ep 0x%x len 0x%zx\n",
|
2012-01-12 13:23:01 +01:00
|
|
|
p->pid, p->ep->nr, p->iov.size);
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
}
|
2008-07-17 22:47:13 +02:00
|
|
|
}
|
|
|
|
|
2012-07-24 17:35:13 +02:00
|
|
|
static ssize_t usbnet_receive(NetClientState *nc, const uint8_t *buf, size_t size)
|
2008-07-17 22:47:13 +02:00
|
|
|
{
|
2013-01-30 12:12:23 +01:00
|
|
|
USBNetState *s = qemu_get_nic_opaque(nc);
|
2012-08-24 14:32:16 +02:00
|
|
|
uint8_t *in_buf = s->in_buf;
|
|
|
|
size_t total_size = size;
|
2008-07-17 22:47:13 +02:00
|
|
|
|
2015-07-15 12:19:05 +02:00
|
|
|
if (!s->dev.config) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2010-11-26 20:20:41 +01:00
|
|
|
if (is_rndis(s)) {
|
2011-11-09 22:09:23 +01:00
|
|
|
if (s->rndis_state != RNDIS_DATA_INITIALIZED) {
|
2009-05-18 14:40:55 +02:00
|
|
|
return -1;
|
2011-11-09 22:09:23 +01:00
|
|
|
}
|
2012-08-24 14:32:16 +02:00
|
|
|
total_size += sizeof(struct rndis_packet_msg_type);
|
|
|
|
}
|
|
|
|
if (total_size > sizeof(s->in_buf)) {
|
|
|
|
return -1;
|
|
|
|
}
|
2008-07-17 22:47:13 +02:00
|
|
|
|
2012-08-24 14:37:29 +02:00
|
|
|
/* Only accept packet if input buffer is empty */
|
|
|
|
if (s->in_len > 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-24 14:32:16 +02:00
|
|
|
if (is_rndis(s)) {
|
|
|
|
struct rndis_packet_msg_type *msg;
|
|
|
|
|
|
|
|
msg = (struct rndis_packet_msg_type *)in_buf;
|
2008-07-17 22:47:13 +02:00
|
|
|
memset(msg, 0, sizeof(struct rndis_packet_msg_type));
|
|
|
|
msg->MessageType = cpu_to_le32(RNDIS_PACKET_MSG);
|
2012-08-24 14:32:16 +02:00
|
|
|
msg->MessageLength = cpu_to_le32(size + sizeof(*msg));
|
|
|
|
msg->DataOffset = cpu_to_le32(sizeof(*msg) - 8);
|
2008-07-17 22:47:13 +02:00
|
|
|
msg->DataLength = cpu_to_le32(size);
|
|
|
|
/* msg->OOBDataOffset;
|
|
|
|
* msg->OOBDataLength;
|
|
|
|
* msg->NumOOBDataElements;
|
|
|
|
* msg->PerPacketInfoOffset;
|
|
|
|
* msg->PerPacketInfoLength;
|
|
|
|
* msg->VcHandle;
|
|
|
|
* msg->Reserved;
|
|
|
|
*/
|
2012-08-24 14:32:16 +02:00
|
|
|
in_buf += sizeof(*msg);
|
2008-07-17 22:47:13 +02:00
|
|
|
}
|
2012-08-24 14:32:16 +02:00
|
|
|
|
|
|
|
memcpy(in_buf, buf, size);
|
|
|
|
s->in_len = total_size;
|
2008-07-17 22:47:13 +02:00
|
|
|
s->in_ptr = 0;
|
2009-05-18 14:40:55 +02:00
|
|
|
return size;
|
2008-07-17 22:47:13 +02:00
|
|
|
}
|
|
|
|
|
2012-07-24 17:35:13 +02:00
|
|
|
static void usbnet_cleanup(NetClientState *nc)
|
2009-04-17 19:11:08 +02:00
|
|
|
{
|
2013-01-30 12:12:23 +01:00
|
|
|
USBNetState *s = qemu_get_nic_opaque(nc);
|
2009-04-17 19:11:08 +02:00
|
|
|
|
2009-12-15 10:20:57 +01:00
|
|
|
s->nic = NULL;
|
2009-04-17 19:11:08 +02:00
|
|
|
}
|
|
|
|
|
2008-07-17 22:47:13 +02:00
|
|
|
static void usb_net_handle_destroy(USBDevice *dev)
|
|
|
|
{
|
|
|
|
USBNetState *s = (USBNetState *) dev;
|
|
|
|
|
2008-07-17 23:00:05 +02:00
|
|
|
/* TODO: remove the nd_table[] entry */
|
2009-12-15 10:20:57 +01:00
|
|
|
rndis_clear_responsequeue(s);
|
2013-01-30 12:12:24 +01:00
|
|
|
qemu_del_nic(s->nic);
|
2008-07-17 22:47:13 +02:00
|
|
|
}
|
|
|
|
|
2009-12-15 10:20:57 +01:00
|
|
|
static NetClientInfo net_usbnet_info = {
|
2012-07-17 16:17:12 +02:00
|
|
|
.type = NET_CLIENT_OPTIONS_KIND_NIC,
|
2009-12-15 10:20:57 +01:00
|
|
|
.size = sizeof(NICState),
|
|
|
|
.receive = usbnet_receive,
|
|
|
|
.cleanup = usbnet_cleanup,
|
|
|
|
};
|
|
|
|
|
2014-09-19 08:48:25 +02:00
|
|
|
static void usb_net_realize(USBDevice *dev, Error **errrp)
|
2008-07-17 22:47:13 +02:00
|
|
|
{
|
2015-05-06 14:55:30 +02:00
|
|
|
USBNetState *s = USB_NET(dev);
|
2008-07-17 22:47:13 +02:00
|
|
|
|
2012-04-20 12:33:30 +02:00
|
|
|
usb_desc_create_serial(dev);
|
2010-11-26 20:20:41 +01:00
|
|
|
usb_desc_init(dev);
|
2008-07-17 22:47:13 +02:00
|
|
|
|
|
|
|
s->rndis_state = RNDIS_UNINITIALIZED;
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_INIT(&s->rndis_resp);
|
2009-08-31 14:23:59 +02:00
|
|
|
|
2008-07-17 22:47:13 +02:00
|
|
|
s->medium = 0; /* NDIS_MEDIUM_802_3 */
|
|
|
|
s->speed = 1000000; /* 100MBps, in 100Bps units */
|
|
|
|
s->media_state = 0; /* NDIS_MEDIA_STATE_CONNECTED */;
|
|
|
|
s->filter = 0;
|
|
|
|
s->vendorid = 0x1234;
|
2012-11-17 12:47:14 +01:00
|
|
|
s->intr = usb_ep_get(dev, USB_TOKEN_IN, 1);
|
2009-12-15 10:20:57 +01:00
|
|
|
|
|
|
|
qemu_macaddr_default_if_unset(&s->conf.macaddr);
|
|
|
|
s->nic = qemu_new_nic(&net_usbnet_info, &s->conf,
|
2011-12-04 18:17:51 +01:00
|
|
|
object_get_typename(OBJECT(s)), s->dev.qdev.id, s);
|
2013-01-30 12:12:22 +01:00
|
|
|
qemu_format_nic_info_str(qemu_get_queue(s->nic), s->conf.macaddr.a);
|
2009-12-15 10:20:57 +01:00
|
|
|
snprintf(s->usbstring_mac, sizeof(s->usbstring_mac),
|
|
|
|
"%02x%02x%02x%02x%02x%02x",
|
|
|
|
0x40,
|
|
|
|
s->conf.macaddr.a[1],
|
|
|
|
s->conf.macaddr.a[2],
|
|
|
|
s->conf.macaddr.a[3],
|
|
|
|
s->conf.macaddr.a[4],
|
|
|
|
s->conf.macaddr.a[5]);
|
2010-11-26 10:25:06 +01:00
|
|
|
usb_desc_set_string(dev, STRING_ETHADDR, s->usbstring_mac);
|
2009-08-31 14:23:59 +02:00
|
|
|
}
|
|
|
|
|
2014-10-07 10:00:20 +02:00
|
|
|
static void usb_net_instance_init(Object *obj)
|
|
|
|
{
|
|
|
|
USBDevice *dev = USB_DEVICE(obj);
|
2015-05-06 14:55:30 +02:00
|
|
|
USBNetState *s = USB_NET(dev);
|
2014-10-07 10:00:20 +02:00
|
|
|
|
|
|
|
device_add_bootindex_property(obj, &s->conf.bootindex,
|
|
|
|
"bootindex", "/ethernet-phy@0",
|
|
|
|
&dev->qdev, NULL);
|
|
|
|
}
|
|
|
|
|
2012-02-27 15:18:47 +01:00
|
|
|
static USBDevice *usb_net_init(USBBus *bus, const char *cmdline)
|
2009-08-31 14:23:59 +02:00
|
|
|
{
|
2012-04-20 21:50:25 +02:00
|
|
|
Error *local_err = NULL;
|
2009-08-31 14:23:59 +02:00
|
|
|
USBDevice *dev;
|
2009-12-15 10:20:57 +01:00
|
|
|
QemuOpts *opts;
|
|
|
|
int idx;
|
2008-07-17 22:47:13 +02:00
|
|
|
|
QemuOpts: Wean off qerror_report_err()
qerror_report_err() is a transitional interface to help with
converting existing monitor commands to QMP. It should not be used
elsewhere.
The only remaining user in qemu-option.c is qemu_opts_parse(). Is it
used in QMP context? If not, we can simply replace
qerror_report_err() by error_report_err().
The uses in qemu-img.c, qemu-io.c, qemu-nbd.c and under tests/ are
clearly not in QMP context.
The uses in vl.c aren't either, because the only QMP command handlers
there are qmp_query_status() and qmp_query_machines(), and they don't
call it.
Remaining uses:
* drive_def(): Command line -drive and such, HMP drive_add and pci_add
* hmp_chardev_add(): HMP chardev-add
* monitor_parse_command(): HMP core
* tmp_config_parse(): Command line -tpmdev
* net_host_device_add(): HMP host_net_add
* net_client_parse(): Command line -net and -netdev
* qemu_global_option(): Command line -global
* vnc_parse_func(): Command line -display, -vnc, default display, HMP
change, QMP change. Bummer.
* qemu_pci_hot_add_nic(): HMP pci_add
* usb_net_init(): Command line -usbdevice, HMP usb_add
Propagate errors through qemu_opts_parse(). Create a convenience
function qemu_opts_parse_noisily() that passes errors to
error_report_err(). Switch all non-QMP users outside tests to it.
That leaves vnc_parse_func(). Propagate errors through it. Since I'm
touching it anyway, rename it to vnc_parse().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-02-13 12:50:26 +01:00
|
|
|
opts = qemu_opts_parse_noisily(qemu_find_opts("net"), cmdline, false);
|
2009-12-15 10:20:57 +01:00
|
|
|
if (!opts) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-02-12 17:52:20 +01:00
|
|
|
qemu_opt_set(opts, "type", "nic", &error_abort);
|
|
|
|
qemu_opt_set(opts, "model", "usb", &error_abort);
|
2008-07-17 22:47:13 +02:00
|
|
|
|
2012-04-20 21:50:25 +02:00
|
|
|
idx = net_client_init(opts, 0, &local_err);
|
2014-01-30 15:07:28 +01:00
|
|
|
if (local_err) {
|
2015-02-12 13:55:05 +01:00
|
|
|
error_report_err(local_err);
|
2009-12-15 10:20:57 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2009-01-07 18:46:21 +01:00
|
|
|
|
2012-02-27 15:18:47 +01:00
|
|
|
dev = usb_create(bus, "usb-net");
|
2009-12-15 10:20:57 +01:00
|
|
|
qdev_set_nic_properties(&dev->qdev, &nd_table[idx]);
|
|
|
|
return dev;
|
2008-07-17 22:47:13 +02:00
|
|
|
}
|
2009-08-31 14:23:59 +02:00
|
|
|
|
2011-07-20 10:06:07 +02:00
|
|
|
static const VMStateDescription vmstate_usb_net = {
|
|
|
|
.name = "usb-net",
|
|
|
|
.unmigratable = 1,
|
|
|
|
};
|
|
|
|
|
2011-12-08 04:34:16 +01:00
|
|
|
static Property net_properties[] = {
|
|
|
|
DEFINE_NIC_PROPERTIES(USBNetState, conf),
|
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
2011-12-15 21:53:10 +01:00
|
|
|
static void usb_net_class_initfn(ObjectClass *klass, void *data)
|
|
|
|
{
|
2011-12-08 04:34:16 +01:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
2011-12-15 21:53:10 +01:00
|
|
|
USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
|
|
|
|
|
2014-09-19 08:48:25 +02:00
|
|
|
uc->realize = usb_net_realize;
|
2011-12-15 21:53:10 +01:00
|
|
|
uc->product_desc = "QEMU USB Network Interface";
|
|
|
|
uc->usb_desc = &desc_net;
|
|
|
|
uc->handle_reset = usb_net_handle_reset;
|
|
|
|
uc->handle_control = usb_net_handle_control;
|
|
|
|
uc->handle_data = usb_net_handle_data;
|
|
|
|
uc->handle_destroy = usb_net_handle_destroy;
|
2013-07-29 16:17:45 +02:00
|
|
|
set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
|
2011-12-08 04:34:16 +01:00
|
|
|
dc->fw_name = "network";
|
|
|
|
dc->vmsd = &vmstate_usb_net;
|
|
|
|
dc->props = net_properties;
|
2011-12-15 21:53:10 +01:00
|
|
|
}
|
|
|
|
|
2013-01-10 16:19:07 +01:00
|
|
|
static const TypeInfo net_info = {
|
2015-05-06 14:55:30 +02:00
|
|
|
.name = TYPE_USB_NET,
|
2011-12-08 04:34:16 +01:00
|
|
|
.parent = TYPE_USB_DEVICE,
|
|
|
|
.instance_size = sizeof(USBNetState),
|
|
|
|
.class_init = usb_net_class_initfn,
|
2014-10-07 10:00:20 +02:00
|
|
|
.instance_init = usb_net_instance_init,
|
2009-08-31 14:23:59 +02:00
|
|
|
};
|
|
|
|
|
2012-02-09 15:20:55 +01:00
|
|
|
static void usb_net_register_types(void)
|
2009-08-31 14:23:59 +02:00
|
|
|
{
|
2011-12-08 04:34:16 +01:00
|
|
|
type_register_static(&net_info);
|
2015-05-06 14:55:30 +02:00
|
|
|
usb_legacy_register(TYPE_USB_NET, "net", usb_net_init);
|
2009-08-31 14:23:59 +02:00
|
|
|
}
|
2012-02-09 15:20:55 +01:00
|
|
|
|
|
|
|
type_init(usb_net_register_types)
|