mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-13 01:36:55 +07:00
a481991467
Here is the big USB 3.5-rc1 pull request for the 3.5-rc1 merge window. It's touches a lot of different parts of the kernel, all USB drivers, due to some API cleanups (getting rid of the ancient err() macro) and some changes that are needed for USB 3.0 power management updates. There are also lots of new drivers, pimarily gadget, but others as well. We deleted a staging driver, which was nice, and finally dropped the obsolete usbfs code, which will make Al happy to never have to touch that again. There were some build errors in the tree that linux-next found a few days ago, but those were fixed by the most recent changes (all were due to us not building with CONFIG_PM disabled.) Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> -----BEGIN PGP SIGNATURE----- Version: GnuPG v2.0.18 (GNU/Linux) iEYEABECAAYFAk+7qs0ACgkQMUfUDdst+ymjOgCfeoWqWk1bsKKt6SZULvQois5i 3csAn1Uapcm8Uswwpnj2v1/2Zh4rBHLA =4jM1 -----END PGP SIGNATURE----- Merge tag 'usb-3.5-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb Pull USB 3.5-rc1 changes from Greg Kroah-Hartman: "Here is the big USB 3.5-rc1 pull request for the 3.5-rc1 merge window. It's touches a lot of different parts of the kernel, all USB drivers, due to some API cleanups (getting rid of the ancient err() macro) and some changes that are needed for USB 3.0 power management updates. There are also lots of new drivers, pimarily gadget, but others as well. We deleted a staging driver, which was nice, and finally dropped the obsolete usbfs code, which will make Al happy to never have to touch that again. There were some build errors in the tree that linux-next found a few days ago, but those were fixed by the most recent changes (all were due to us not building with CONFIG_PM disabled.) Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>" * tag 'usb-3.5-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (477 commits) xhci: Fix DIV_ROUND_UP compile error. xhci: Fix compile with CONFIG_USB_SUSPEND=n USB: Fix core compile with CONFIG_USB_SUSPEND=n brcm80211: Fix compile error for .disable_hub_initiated_lpm. Revert "USB: EHCI: work around bug in the Philips ISP1562 controller" MAINTAINERS: Add myself as maintainer to the USB PHY Layer USB: EHCI: fix command register configuration lost problem USB: Remove races in devio.c USB: ehci-platform: remove update_device USB: Disable hub-initiated LPM for comms devices. xhci: Add Intel U1/U2 timeout policy. xhci: Add infrastructure for host-specific LPM policies. USB: Add macros for interrupt endpoint types. xhci: Reserve one command for USB3 LPM disable. xhci: Some Evaluate Context commands must succeed. USB: Disable USB 3.0 LPM in critical sections. USB: Add support to enable/disable USB3 link states. USB: Allow drivers to disable hub-initiated LPM. USB: Calculate USB 3.0 exit latencies for LPM. USB: Refactor code to set LPM support flag. ... Conflicts: arch/arm/mach-exynos/mach-nuri.c arch/arm/mach-exynos/mach-universal_c210.c drivers/net/wireless/ath/ath6kl/usb.c
919 lines
26 KiB
C
919 lines
26 KiB
C
/*
|
|
* f_rndis.c -- RNDIS link function driver
|
|
*
|
|
* Copyright (C) 2003-2005,2008 David Brownell
|
|
* Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
|
|
* Copyright (C) 2008 Nokia Corporation
|
|
* Copyright (C) 2009 Samsung Electronics
|
|
* Author: Michal Nazarewicz (mina86@mina86.com)
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*/
|
|
|
|
/* #define VERBOSE_DEBUG */
|
|
|
|
#include <linux/slab.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/device.h>
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/atomic.h>
|
|
|
|
#include "u_ether.h"
|
|
#include "rndis.h"
|
|
|
|
|
|
/*
|
|
* This function is an RNDIS Ethernet port -- a Microsoft protocol that's
|
|
* been promoted instead of the standard CDC Ethernet. The published RNDIS
|
|
* spec is ambiguous, incomplete, and needlessly complex. Variants such as
|
|
* ActiveSync have even worse status in terms of specification.
|
|
*
|
|
* In short: it's a protocol controlled by (and for) Microsoft, not for an
|
|
* Open ecosystem or markets. Linux supports it *only* because Microsoft
|
|
* doesn't support the CDC Ethernet standard.
|
|
*
|
|
* The RNDIS data transfer model is complex, with multiple Ethernet packets
|
|
* per USB message, and out of band data. The control model is built around
|
|
* what's essentially an "RNDIS RPC" protocol. It's all wrapped in a CDC ACM
|
|
* (modem, not Ethernet) veneer, with those ACM descriptors being entirely
|
|
* useless (they're ignored). RNDIS expects to be the only function in its
|
|
* configuration, so it's no real help if you need composite devices; and
|
|
* it expects to be the first configuration too.
|
|
*
|
|
* There is a single technical advantage of RNDIS over CDC Ethernet, if you
|
|
* discount the fluff that its RPC can be made to deliver: it doesn't need
|
|
* a NOP altsetting for the data interface. That lets it work on some of the
|
|
* "so smart it's stupid" hardware which takes over configuration changes
|
|
* from the software, and adds restrictions like "no altsettings".
|
|
*
|
|
* Unfortunately MSFT's RNDIS drivers are buggy. They hang or oops, and
|
|
* have all sorts of contrary-to-specification oddities that can prevent
|
|
* them from working sanely. Since bugfixes (or accurate specs, letting
|
|
* Linux work around those bugs) are unlikely to ever come from MSFT, you
|
|
* may want to avoid using RNDIS on purely operational grounds.
|
|
*
|
|
* Omissions from the RNDIS 1.0 specification include:
|
|
*
|
|
* - Power management ... references data that's scattered around lots
|
|
* of other documentation, which is incorrect/incomplete there too.
|
|
*
|
|
* - There are various undocumented protocol requirements, like the need
|
|
* to send garbage in some control-OUT messages.
|
|
*
|
|
* - MS-Windows drivers sometimes emit undocumented requests.
|
|
*/
|
|
|
|
struct f_rndis {
|
|
struct gether port;
|
|
u8 ctrl_id, data_id;
|
|
u8 ethaddr[ETH_ALEN];
|
|
u32 vendorID;
|
|
const char *manufacturer;
|
|
int config;
|
|
|
|
struct usb_ep *notify;
|
|
struct usb_request *notify_req;
|
|
atomic_t notify_count;
|
|
};
|
|
|
|
static inline struct f_rndis *func_to_rndis(struct usb_function *f)
|
|
{
|
|
return container_of(f, struct f_rndis, port.func);
|
|
}
|
|
|
|
/* peak (theoretical) bulk transfer rate in bits-per-second */
|
|
static unsigned int bitrate(struct usb_gadget *g)
|
|
{
|
|
if (gadget_is_superspeed(g) && g->speed == USB_SPEED_SUPER)
|
|
return 13 * 1024 * 8 * 1000 * 8;
|
|
else if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
|
|
return 13 * 512 * 8 * 1000 * 8;
|
|
else
|
|
return 19 * 64 * 1 * 1000 * 8;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
/*
|
|
*/
|
|
|
|
#define LOG2_STATUS_INTERVAL_MSEC 5 /* 1 << 5 == 32 msec */
|
|
#define STATUS_BYTECOUNT 8 /* 8 bytes data */
|
|
|
|
|
|
/* interface descriptor: */
|
|
|
|
static struct usb_interface_descriptor rndis_control_intf = {
|
|
.bLength = sizeof rndis_control_intf,
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
|
|
/* .bInterfaceNumber = DYNAMIC */
|
|
/* status endpoint is optional; this could be patched later */
|
|
.bNumEndpoints = 1,
|
|
.bInterfaceClass = USB_CLASS_COMM,
|
|
.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
|
|
.bInterfaceProtocol = USB_CDC_ACM_PROTO_VENDOR,
|
|
/* .iInterface = DYNAMIC */
|
|
};
|
|
|
|
static struct usb_cdc_header_desc header_desc = {
|
|
.bLength = sizeof header_desc,
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
|
.bDescriptorSubType = USB_CDC_HEADER_TYPE,
|
|
|
|
.bcdCDC = cpu_to_le16(0x0110),
|
|
};
|
|
|
|
static struct usb_cdc_call_mgmt_descriptor call_mgmt_descriptor = {
|
|
.bLength = sizeof call_mgmt_descriptor,
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
|
.bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE,
|
|
|
|
.bmCapabilities = 0x00,
|
|
.bDataInterface = 0x01,
|
|
};
|
|
|
|
static struct usb_cdc_acm_descriptor rndis_acm_descriptor = {
|
|
.bLength = sizeof rndis_acm_descriptor,
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
|
.bDescriptorSubType = USB_CDC_ACM_TYPE,
|
|
|
|
.bmCapabilities = 0x00,
|
|
};
|
|
|
|
static struct usb_cdc_union_desc rndis_union_desc = {
|
|
.bLength = sizeof(rndis_union_desc),
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
|
.bDescriptorSubType = USB_CDC_UNION_TYPE,
|
|
/* .bMasterInterface0 = DYNAMIC */
|
|
/* .bSlaveInterface0 = DYNAMIC */
|
|
};
|
|
|
|
/* the data interface has two bulk endpoints */
|
|
|
|
static struct usb_interface_descriptor rndis_data_intf = {
|
|
.bLength = sizeof rndis_data_intf,
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
|
|
/* .bInterfaceNumber = DYNAMIC */
|
|
.bNumEndpoints = 2,
|
|
.bInterfaceClass = USB_CLASS_CDC_DATA,
|
|
.bInterfaceSubClass = 0,
|
|
.bInterfaceProtocol = 0,
|
|
/* .iInterface = DYNAMIC */
|
|
};
|
|
|
|
|
|
static struct usb_interface_assoc_descriptor
|
|
rndis_iad_descriptor = {
|
|
.bLength = sizeof rndis_iad_descriptor,
|
|
.bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
|
|
|
|
.bFirstInterface = 0, /* XXX, hardcoded */
|
|
.bInterfaceCount = 2, // control + data
|
|
.bFunctionClass = USB_CLASS_COMM,
|
|
.bFunctionSubClass = USB_CDC_SUBCLASS_ETHERNET,
|
|
.bFunctionProtocol = USB_CDC_PROTO_NONE,
|
|
/* .iFunction = DYNAMIC */
|
|
};
|
|
|
|
/* full speed support: */
|
|
|
|
static struct usb_endpoint_descriptor fs_notify_desc = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_INT,
|
|
.wMaxPacketSize = cpu_to_le16(STATUS_BYTECOUNT),
|
|
.bInterval = 1 << LOG2_STATUS_INTERVAL_MSEC,
|
|
};
|
|
|
|
static struct usb_endpoint_descriptor fs_in_desc = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
};
|
|
|
|
static struct usb_endpoint_descriptor fs_out_desc = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_OUT,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
};
|
|
|
|
static struct usb_descriptor_header *eth_fs_function[] = {
|
|
(struct usb_descriptor_header *) &rndis_iad_descriptor,
|
|
|
|
/* control interface matches ACM, not Ethernet */
|
|
(struct usb_descriptor_header *) &rndis_control_intf,
|
|
(struct usb_descriptor_header *) &header_desc,
|
|
(struct usb_descriptor_header *) &call_mgmt_descriptor,
|
|
(struct usb_descriptor_header *) &rndis_acm_descriptor,
|
|
(struct usb_descriptor_header *) &rndis_union_desc,
|
|
(struct usb_descriptor_header *) &fs_notify_desc,
|
|
|
|
/* data interface has no altsetting */
|
|
(struct usb_descriptor_header *) &rndis_data_intf,
|
|
(struct usb_descriptor_header *) &fs_in_desc,
|
|
(struct usb_descriptor_header *) &fs_out_desc,
|
|
NULL,
|
|
};
|
|
|
|
/* high speed support: */
|
|
|
|
static struct usb_endpoint_descriptor hs_notify_desc = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_INT,
|
|
.wMaxPacketSize = cpu_to_le16(STATUS_BYTECOUNT),
|
|
.bInterval = LOG2_STATUS_INTERVAL_MSEC + 4,
|
|
};
|
|
|
|
static struct usb_endpoint_descriptor hs_in_desc = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = cpu_to_le16(512),
|
|
};
|
|
|
|
static struct usb_endpoint_descriptor hs_out_desc = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_OUT,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = cpu_to_le16(512),
|
|
};
|
|
|
|
static struct usb_descriptor_header *eth_hs_function[] = {
|
|
(struct usb_descriptor_header *) &rndis_iad_descriptor,
|
|
|
|
/* control interface matches ACM, not Ethernet */
|
|
(struct usb_descriptor_header *) &rndis_control_intf,
|
|
(struct usb_descriptor_header *) &header_desc,
|
|
(struct usb_descriptor_header *) &call_mgmt_descriptor,
|
|
(struct usb_descriptor_header *) &rndis_acm_descriptor,
|
|
(struct usb_descriptor_header *) &rndis_union_desc,
|
|
(struct usb_descriptor_header *) &hs_notify_desc,
|
|
|
|
/* data interface has no altsetting */
|
|
(struct usb_descriptor_header *) &rndis_data_intf,
|
|
(struct usb_descriptor_header *) &hs_in_desc,
|
|
(struct usb_descriptor_header *) &hs_out_desc,
|
|
NULL,
|
|
};
|
|
|
|
/* super speed support: */
|
|
|
|
static struct usb_endpoint_descriptor ss_notify_desc = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_INT,
|
|
.wMaxPacketSize = cpu_to_le16(STATUS_BYTECOUNT),
|
|
.bInterval = LOG2_STATUS_INTERVAL_MSEC + 4,
|
|
};
|
|
|
|
static struct usb_ss_ep_comp_descriptor ss_intr_comp_desc = {
|
|
.bLength = sizeof ss_intr_comp_desc,
|
|
.bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
|
|
|
|
/* the following 3 values can be tweaked if necessary */
|
|
/* .bMaxBurst = 0, */
|
|
/* .bmAttributes = 0, */
|
|
.wBytesPerInterval = cpu_to_le16(STATUS_BYTECOUNT),
|
|
};
|
|
|
|
static struct usb_endpoint_descriptor ss_in_desc = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_IN,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = cpu_to_le16(1024),
|
|
};
|
|
|
|
static struct usb_endpoint_descriptor ss_out_desc = {
|
|
.bLength = USB_DT_ENDPOINT_SIZE,
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_OUT,
|
|
.bmAttributes = USB_ENDPOINT_XFER_BULK,
|
|
.wMaxPacketSize = cpu_to_le16(1024),
|
|
};
|
|
|
|
static struct usb_ss_ep_comp_descriptor ss_bulk_comp_desc = {
|
|
.bLength = sizeof ss_bulk_comp_desc,
|
|
.bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
|
|
|
|
/* the following 2 values can be tweaked if necessary */
|
|
/* .bMaxBurst = 0, */
|
|
/* .bmAttributes = 0, */
|
|
};
|
|
|
|
static struct usb_descriptor_header *eth_ss_function[] = {
|
|
(struct usb_descriptor_header *) &rndis_iad_descriptor,
|
|
|
|
/* control interface matches ACM, not Ethernet */
|
|
(struct usb_descriptor_header *) &rndis_control_intf,
|
|
(struct usb_descriptor_header *) &header_desc,
|
|
(struct usb_descriptor_header *) &call_mgmt_descriptor,
|
|
(struct usb_descriptor_header *) &rndis_acm_descriptor,
|
|
(struct usb_descriptor_header *) &rndis_union_desc,
|
|
(struct usb_descriptor_header *) &ss_notify_desc,
|
|
(struct usb_descriptor_header *) &ss_intr_comp_desc,
|
|
|
|
/* data interface has no altsetting */
|
|
(struct usb_descriptor_header *) &rndis_data_intf,
|
|
(struct usb_descriptor_header *) &ss_in_desc,
|
|
(struct usb_descriptor_header *) &ss_bulk_comp_desc,
|
|
(struct usb_descriptor_header *) &ss_out_desc,
|
|
(struct usb_descriptor_header *) &ss_bulk_comp_desc,
|
|
NULL,
|
|
};
|
|
|
|
/* string descriptors: */
|
|
|
|
static struct usb_string rndis_string_defs[] = {
|
|
[0].s = "RNDIS Communications Control",
|
|
[1].s = "RNDIS Ethernet Data",
|
|
[2].s = "RNDIS",
|
|
{ } /* end of list */
|
|
};
|
|
|
|
static struct usb_gadget_strings rndis_string_table = {
|
|
.language = 0x0409, /* en-us */
|
|
.strings = rndis_string_defs,
|
|
};
|
|
|
|
static struct usb_gadget_strings *rndis_strings[] = {
|
|
&rndis_string_table,
|
|
NULL,
|
|
};
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
static struct sk_buff *rndis_add_header(struct gether *port,
|
|
struct sk_buff *skb)
|
|
{
|
|
struct sk_buff *skb2;
|
|
|
|
skb2 = skb_realloc_headroom(skb, sizeof(struct rndis_packet_msg_type));
|
|
if (skb2)
|
|
rndis_add_hdr(skb2);
|
|
|
|
dev_kfree_skb_any(skb);
|
|
return skb2;
|
|
}
|
|
|
|
static void rndis_response_available(void *_rndis)
|
|
{
|
|
struct f_rndis *rndis = _rndis;
|
|
struct usb_request *req = rndis->notify_req;
|
|
struct usb_composite_dev *cdev = rndis->port.func.config->cdev;
|
|
__le32 *data = req->buf;
|
|
int status;
|
|
|
|
if (atomic_inc_return(&rndis->notify_count) != 1)
|
|
return;
|
|
|
|
/* Send RNDIS RESPONSE_AVAILABLE notification; a
|
|
* USB_CDC_NOTIFY_RESPONSE_AVAILABLE "should" work too
|
|
*
|
|
* This is the only notification defined by RNDIS.
|
|
*/
|
|
data[0] = cpu_to_le32(1);
|
|
data[1] = cpu_to_le32(0);
|
|
|
|
status = usb_ep_queue(rndis->notify, req, GFP_ATOMIC);
|
|
if (status) {
|
|
atomic_dec(&rndis->notify_count);
|
|
DBG(cdev, "notify/0 --> %d\n", status);
|
|
}
|
|
}
|
|
|
|
static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
struct f_rndis *rndis = req->context;
|
|
struct usb_composite_dev *cdev = rndis->port.func.config->cdev;
|
|
int status = req->status;
|
|
|
|
/* after TX:
|
|
* - USB_CDC_GET_ENCAPSULATED_RESPONSE (ep0/control)
|
|
* - RNDIS_RESPONSE_AVAILABLE (status/irq)
|
|
*/
|
|
switch (status) {
|
|
case -ECONNRESET:
|
|
case -ESHUTDOWN:
|
|
/* connection gone */
|
|
atomic_set(&rndis->notify_count, 0);
|
|
break;
|
|
default:
|
|
DBG(cdev, "RNDIS %s response error %d, %d/%d\n",
|
|
ep->name, status,
|
|
req->actual, req->length);
|
|
/* FALLTHROUGH */
|
|
case 0:
|
|
if (ep != rndis->notify)
|
|
break;
|
|
|
|
/* handle multiple pending RNDIS_RESPONSE_AVAILABLE
|
|
* notifications by resending until we're done
|
|
*/
|
|
if (atomic_dec_and_test(&rndis->notify_count))
|
|
break;
|
|
status = usb_ep_queue(rndis->notify, req, GFP_ATOMIC);
|
|
if (status) {
|
|
atomic_dec(&rndis->notify_count);
|
|
DBG(cdev, "notify/1 --> %d\n", status);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void rndis_command_complete(struct usb_ep *ep, struct usb_request *req)
|
|
{
|
|
struct f_rndis *rndis = req->context;
|
|
struct usb_composite_dev *cdev = rndis->port.func.config->cdev;
|
|
int status;
|
|
|
|
/* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */
|
|
// spin_lock(&dev->lock);
|
|
status = rndis_msg_parser(rndis->config, (u8 *) req->buf);
|
|
if (status < 0)
|
|
ERROR(cdev, "RNDIS command error %d, %d/%d\n",
|
|
status, req->actual, req->length);
|
|
// spin_unlock(&dev->lock);
|
|
}
|
|
|
|
static int
|
|
rndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
|
|
{
|
|
struct f_rndis *rndis = func_to_rndis(f);
|
|
struct usb_composite_dev *cdev = f->config->cdev;
|
|
struct usb_request *req = cdev->req;
|
|
int value = -EOPNOTSUPP;
|
|
u16 w_index = le16_to_cpu(ctrl->wIndex);
|
|
u16 w_value = le16_to_cpu(ctrl->wValue);
|
|
u16 w_length = le16_to_cpu(ctrl->wLength);
|
|
|
|
/* composite driver infrastructure handles everything except
|
|
* CDC class messages; interface activation uses set_alt().
|
|
*/
|
|
switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
|
|
|
|
/* RNDIS uses the CDC command encapsulation mechanism to implement
|
|
* an RPC scheme, with much getting/setting of attributes by OID.
|
|
*/
|
|
case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
|
|
| USB_CDC_SEND_ENCAPSULATED_COMMAND:
|
|
if (w_value || w_index != rndis->ctrl_id)
|
|
goto invalid;
|
|
/* read the request; process it later */
|
|
value = w_length;
|
|
req->complete = rndis_command_complete;
|
|
req->context = rndis;
|
|
/* later, rndis_response_available() sends a notification */
|
|
break;
|
|
|
|
case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
|
|
| USB_CDC_GET_ENCAPSULATED_RESPONSE:
|
|
if (w_value || w_index != rndis->ctrl_id)
|
|
goto invalid;
|
|
else {
|
|
u8 *buf;
|
|
u32 n;
|
|
|
|
/* return the result */
|
|
buf = rndis_get_next_response(rndis->config, &n);
|
|
if (buf) {
|
|
memcpy(req->buf, buf, n);
|
|
req->complete = rndis_response_complete;
|
|
req->context = rndis;
|
|
rndis_free_response(rndis->config, buf);
|
|
value = n;
|
|
}
|
|
/* else stalls ... spec says to avoid that */
|
|
}
|
|
break;
|
|
|
|
default:
|
|
invalid:
|
|
VDBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
|
|
ctrl->bRequestType, ctrl->bRequest,
|
|
w_value, w_index, w_length);
|
|
}
|
|
|
|
/* respond with data transfer or status phase? */
|
|
if (value >= 0) {
|
|
DBG(cdev, "rndis req%02x.%02x v%04x i%04x l%d\n",
|
|
ctrl->bRequestType, ctrl->bRequest,
|
|
w_value, w_index, w_length);
|
|
req->zero = (value < w_length);
|
|
req->length = value;
|
|
value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
|
|
if (value < 0)
|
|
ERROR(cdev, "rndis response on err %d\n", value);
|
|
}
|
|
|
|
/* device either stalls (value < 0) or reports success */
|
|
return value;
|
|
}
|
|
|
|
|
|
static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
|
|
{
|
|
struct f_rndis *rndis = func_to_rndis(f);
|
|
struct usb_composite_dev *cdev = f->config->cdev;
|
|
|
|
/* we know alt == 0 */
|
|
|
|
if (intf == rndis->ctrl_id) {
|
|
if (rndis->notify->driver_data) {
|
|
VDBG(cdev, "reset rndis control %d\n", intf);
|
|
usb_ep_disable(rndis->notify);
|
|
}
|
|
if (!rndis->notify->desc) {
|
|
VDBG(cdev, "init rndis ctrl %d\n", intf);
|
|
if (config_ep_by_speed(cdev->gadget, f, rndis->notify))
|
|
goto fail;
|
|
}
|
|
usb_ep_enable(rndis->notify);
|
|
rndis->notify->driver_data = rndis;
|
|
|
|
} else if (intf == rndis->data_id) {
|
|
struct net_device *net;
|
|
|
|
if (rndis->port.in_ep->driver_data) {
|
|
DBG(cdev, "reset rndis\n");
|
|
gether_disconnect(&rndis->port);
|
|
}
|
|
|
|
if (!rndis->port.in_ep->desc || !rndis->port.out_ep->desc) {
|
|
DBG(cdev, "init rndis\n");
|
|
if (config_ep_by_speed(cdev->gadget, f,
|
|
rndis->port.in_ep) ||
|
|
config_ep_by_speed(cdev->gadget, f,
|
|
rndis->port.out_ep)) {
|
|
rndis->port.in_ep->desc = NULL;
|
|
rndis->port.out_ep->desc = NULL;
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
/* Avoid ZLPs; they can be troublesome. */
|
|
rndis->port.is_zlp_ok = false;
|
|
|
|
/* RNDIS should be in the "RNDIS uninitialized" state,
|
|
* either never activated or after rndis_uninit().
|
|
*
|
|
* We don't want data to flow here until a nonzero packet
|
|
* filter is set, at which point it enters "RNDIS data
|
|
* initialized" state ... but we do want the endpoints
|
|
* to be activated. It's a strange little state.
|
|
*
|
|
* REVISIT the RNDIS gadget code has done this wrong for a
|
|
* very long time. We need another call to the link layer
|
|
* code -- gether_updown(...bool) maybe -- to do it right.
|
|
*/
|
|
rndis->port.cdc_filter = 0;
|
|
|
|
DBG(cdev, "RNDIS RX/TX early activation ... \n");
|
|
net = gether_connect(&rndis->port);
|
|
if (IS_ERR(net))
|
|
return PTR_ERR(net);
|
|
|
|
rndis_set_param_dev(rndis->config, net,
|
|
&rndis->port.cdc_filter);
|
|
} else
|
|
goto fail;
|
|
|
|
return 0;
|
|
fail:
|
|
return -EINVAL;
|
|
}
|
|
|
|
static void rndis_disable(struct usb_function *f)
|
|
{
|
|
struct f_rndis *rndis = func_to_rndis(f);
|
|
struct usb_composite_dev *cdev = f->config->cdev;
|
|
|
|
if (!rndis->notify->driver_data)
|
|
return;
|
|
|
|
DBG(cdev, "rndis deactivated\n");
|
|
|
|
rndis_uninit(rndis->config);
|
|
gether_disconnect(&rndis->port);
|
|
|
|
usb_ep_disable(rndis->notify);
|
|
rndis->notify->driver_data = NULL;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
/*
|
|
* This isn't quite the same mechanism as CDC Ethernet, since the
|
|
* notification scheme passes less data, but the same set of link
|
|
* states must be tested. A key difference is that altsettings are
|
|
* not used to tell whether the link should send packets or not.
|
|
*/
|
|
|
|
static void rndis_open(struct gether *geth)
|
|
{
|
|
struct f_rndis *rndis = func_to_rndis(&geth->func);
|
|
struct usb_composite_dev *cdev = geth->func.config->cdev;
|
|
|
|
DBG(cdev, "%s\n", __func__);
|
|
|
|
rndis_set_param_medium(rndis->config, RNDIS_MEDIUM_802_3,
|
|
bitrate(cdev->gadget) / 100);
|
|
rndis_signal_connect(rndis->config);
|
|
}
|
|
|
|
static void rndis_close(struct gether *geth)
|
|
{
|
|
struct f_rndis *rndis = func_to_rndis(&geth->func);
|
|
|
|
DBG(geth->func.config->cdev, "%s\n", __func__);
|
|
|
|
rndis_set_param_medium(rndis->config, RNDIS_MEDIUM_802_3, 0);
|
|
rndis_signal_disconnect(rndis->config);
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
/* ethernet function driver setup/binding */
|
|
|
|
static int
|
|
rndis_bind(struct usb_configuration *c, struct usb_function *f)
|
|
{
|
|
struct usb_composite_dev *cdev = c->cdev;
|
|
struct f_rndis *rndis = func_to_rndis(f);
|
|
int status;
|
|
struct usb_ep *ep;
|
|
|
|
/* allocate instance-specific interface IDs */
|
|
status = usb_interface_id(c, f);
|
|
if (status < 0)
|
|
goto fail;
|
|
rndis->ctrl_id = status;
|
|
rndis_iad_descriptor.bFirstInterface = status;
|
|
|
|
rndis_control_intf.bInterfaceNumber = status;
|
|
rndis_union_desc.bMasterInterface0 = status;
|
|
|
|
status = usb_interface_id(c, f);
|
|
if (status < 0)
|
|
goto fail;
|
|
rndis->data_id = status;
|
|
|
|
rndis_data_intf.bInterfaceNumber = status;
|
|
rndis_union_desc.bSlaveInterface0 = status;
|
|
|
|
status = -ENODEV;
|
|
|
|
/* allocate instance-specific endpoints */
|
|
ep = usb_ep_autoconfig(cdev->gadget, &fs_in_desc);
|
|
if (!ep)
|
|
goto fail;
|
|
rndis->port.in_ep = ep;
|
|
ep->driver_data = cdev; /* claim */
|
|
|
|
ep = usb_ep_autoconfig(cdev->gadget, &fs_out_desc);
|
|
if (!ep)
|
|
goto fail;
|
|
rndis->port.out_ep = ep;
|
|
ep->driver_data = cdev; /* claim */
|
|
|
|
/* NOTE: a status/notification endpoint is, strictly speaking,
|
|
* optional. We don't treat it that way though! It's simpler,
|
|
* and some newer profiles don't treat it as optional.
|
|
*/
|
|
ep = usb_ep_autoconfig(cdev->gadget, &fs_notify_desc);
|
|
if (!ep)
|
|
goto fail;
|
|
rndis->notify = ep;
|
|
ep->driver_data = cdev; /* claim */
|
|
|
|
status = -ENOMEM;
|
|
|
|
/* allocate notification request and buffer */
|
|
rndis->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL);
|
|
if (!rndis->notify_req)
|
|
goto fail;
|
|
rndis->notify_req->buf = kmalloc(STATUS_BYTECOUNT, GFP_KERNEL);
|
|
if (!rndis->notify_req->buf)
|
|
goto fail;
|
|
rndis->notify_req->length = STATUS_BYTECOUNT;
|
|
rndis->notify_req->context = rndis;
|
|
rndis->notify_req->complete = rndis_response_complete;
|
|
|
|
/* copy descriptors, and track endpoint copies */
|
|
f->descriptors = usb_copy_descriptors(eth_fs_function);
|
|
if (!f->descriptors)
|
|
goto fail;
|
|
|
|
/* support all relevant hardware speeds... we expect that when
|
|
* hardware is dual speed, all bulk-capable endpoints work at
|
|
* both speeds
|
|
*/
|
|
if (gadget_is_dualspeed(c->cdev->gadget)) {
|
|
hs_in_desc.bEndpointAddress =
|
|
fs_in_desc.bEndpointAddress;
|
|
hs_out_desc.bEndpointAddress =
|
|
fs_out_desc.bEndpointAddress;
|
|
hs_notify_desc.bEndpointAddress =
|
|
fs_notify_desc.bEndpointAddress;
|
|
|
|
/* copy descriptors, and track endpoint copies */
|
|
f->hs_descriptors = usb_copy_descriptors(eth_hs_function);
|
|
if (!f->hs_descriptors)
|
|
goto fail;
|
|
}
|
|
|
|
if (gadget_is_superspeed(c->cdev->gadget)) {
|
|
ss_in_desc.bEndpointAddress =
|
|
fs_in_desc.bEndpointAddress;
|
|
ss_out_desc.bEndpointAddress =
|
|
fs_out_desc.bEndpointAddress;
|
|
ss_notify_desc.bEndpointAddress =
|
|
fs_notify_desc.bEndpointAddress;
|
|
|
|
/* copy descriptors, and track endpoint copies */
|
|
f->ss_descriptors = usb_copy_descriptors(eth_ss_function);
|
|
if (!f->ss_descriptors)
|
|
goto fail;
|
|
}
|
|
|
|
rndis->port.open = rndis_open;
|
|
rndis->port.close = rndis_close;
|
|
|
|
status = rndis_register(rndis_response_available, rndis);
|
|
if (status < 0)
|
|
goto fail;
|
|
rndis->config = status;
|
|
|
|
rndis_set_param_medium(rndis->config, RNDIS_MEDIUM_802_3, 0);
|
|
rndis_set_host_mac(rndis->config, rndis->ethaddr);
|
|
|
|
if (rndis->manufacturer && rndis->vendorID &&
|
|
rndis_set_param_vendor(rndis->config, rndis->vendorID,
|
|
rndis->manufacturer))
|
|
goto fail;
|
|
|
|
/* NOTE: all that is done without knowing or caring about
|
|
* the network link ... which is unavailable to this code
|
|
* until we're activated via set_alt().
|
|
*/
|
|
|
|
DBG(cdev, "RNDIS: %s speed IN/%s OUT/%s NOTIFY/%s\n",
|
|
gadget_is_superspeed(c->cdev->gadget) ? "super" :
|
|
gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
|
|
rndis->port.in_ep->name, rndis->port.out_ep->name,
|
|
rndis->notify->name);
|
|
return 0;
|
|
|
|
fail:
|
|
if (gadget_is_superspeed(c->cdev->gadget) && f->ss_descriptors)
|
|
usb_free_descriptors(f->ss_descriptors);
|
|
if (gadget_is_dualspeed(c->cdev->gadget) && f->hs_descriptors)
|
|
usb_free_descriptors(f->hs_descriptors);
|
|
if (f->descriptors)
|
|
usb_free_descriptors(f->descriptors);
|
|
|
|
if (rndis->notify_req) {
|
|
kfree(rndis->notify_req->buf);
|
|
usb_ep_free_request(rndis->notify, rndis->notify_req);
|
|
}
|
|
|
|
/* we might as well release our claims on endpoints */
|
|
if (rndis->notify)
|
|
rndis->notify->driver_data = NULL;
|
|
if (rndis->port.out_ep->desc)
|
|
rndis->port.out_ep->driver_data = NULL;
|
|
if (rndis->port.in_ep->desc)
|
|
rndis->port.in_ep->driver_data = NULL;
|
|
|
|
ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
|
|
|
|
return status;
|
|
}
|
|
|
|
static void
|
|
rndis_unbind(struct usb_configuration *c, struct usb_function *f)
|
|
{
|
|
struct f_rndis *rndis = func_to_rndis(f);
|
|
|
|
rndis_deregister(rndis->config);
|
|
rndis_exit();
|
|
rndis_string_defs[0].id = 0;
|
|
|
|
if (gadget_is_superspeed(c->cdev->gadget))
|
|
usb_free_descriptors(f->ss_descriptors);
|
|
if (gadget_is_dualspeed(c->cdev->gadget))
|
|
usb_free_descriptors(f->hs_descriptors);
|
|
usb_free_descriptors(f->descriptors);
|
|
|
|
kfree(rndis->notify_req->buf);
|
|
usb_ep_free_request(rndis->notify, rndis->notify_req);
|
|
|
|
kfree(rndis);
|
|
}
|
|
|
|
/* Some controllers can't support RNDIS ... */
|
|
static inline bool can_support_rndis(struct usb_configuration *c)
|
|
{
|
|
/* everything else is *presumably* fine */
|
|
return true;
|
|
}
|
|
|
|
int
|
|
rndis_bind_config_vendor(struct usb_configuration *c, u8 ethaddr[ETH_ALEN],
|
|
u32 vendorID, const char *manufacturer)
|
|
{
|
|
struct f_rndis *rndis;
|
|
int status;
|
|
|
|
if (!can_support_rndis(c) || !ethaddr)
|
|
return -EINVAL;
|
|
|
|
/* maybe allocate device-global string IDs */
|
|
if (rndis_string_defs[0].id == 0) {
|
|
|
|
/* ... and setup RNDIS itself */
|
|
status = rndis_init();
|
|
if (status < 0)
|
|
return status;
|
|
|
|
/* control interface label */
|
|
status = usb_string_id(c->cdev);
|
|
if (status < 0)
|
|
return status;
|
|
rndis_string_defs[0].id = status;
|
|
rndis_control_intf.iInterface = status;
|
|
|
|
/* data interface label */
|
|
status = usb_string_id(c->cdev);
|
|
if (status < 0)
|
|
return status;
|
|
rndis_string_defs[1].id = status;
|
|
rndis_data_intf.iInterface = status;
|
|
|
|
/* IAD iFunction label */
|
|
status = usb_string_id(c->cdev);
|
|
if (status < 0)
|
|
return status;
|
|
rndis_string_defs[2].id = status;
|
|
rndis_iad_descriptor.iFunction = status;
|
|
}
|
|
|
|
/* allocate and initialize one new instance */
|
|
status = -ENOMEM;
|
|
rndis = kzalloc(sizeof *rndis, GFP_KERNEL);
|
|
if (!rndis)
|
|
goto fail;
|
|
|
|
memcpy(rndis->ethaddr, ethaddr, ETH_ALEN);
|
|
rndis->vendorID = vendorID;
|
|
rndis->manufacturer = manufacturer;
|
|
|
|
/* RNDIS activates when the host changes this filter */
|
|
rndis->port.cdc_filter = 0;
|
|
|
|
/* RNDIS has special (and complex) framing */
|
|
rndis->port.header_len = sizeof(struct rndis_packet_msg_type);
|
|
rndis->port.wrap = rndis_add_header;
|
|
rndis->port.unwrap = rndis_rm_hdr;
|
|
|
|
rndis->port.func.name = "rndis";
|
|
rndis->port.func.strings = rndis_strings;
|
|
/* descriptors are per-instance copies */
|
|
rndis->port.func.bind = rndis_bind;
|
|
rndis->port.func.unbind = rndis_unbind;
|
|
rndis->port.func.set_alt = rndis_set_alt;
|
|
rndis->port.func.setup = rndis_setup;
|
|
rndis->port.func.disable = rndis_disable;
|
|
|
|
status = usb_add_function(c, &rndis->port.func);
|
|
if (status) {
|
|
kfree(rndis);
|
|
fail:
|
|
rndis_exit();
|
|
}
|
|
return status;
|
|
}
|