Revert "[ALPS05269737] USB: Enhance RNDIS Performance"

Reason for revert: Mediatek "optimized" RNDIS so well that they literally broke NCM This reverts commit 3f2cec825b. Change-Id: Idf19e3761a9ce31f9a38c357ae758c87afdc0d78 Signed-off-by: Woomymy <woomy@woomy.be>
2025-04-05 17:11:18 +02:00
parent 3b0970a18a
commit 6c6ad89f18
5 changed files with 296 additions and 964 deletions
--- a/drivers/usb/gadget/function/f_rndis.c
+++ b/drivers/usb/gadget/function/f_rndis.c
@@ -25,7 +25,6 @@
 #include "rndis.h"
 #include "configfs.h"

-#define F_RNDIS_LOG "[USB_RNDIS]"
 /*
 * This function is an RNDIS Ethernet port -- a Microsoft protocol that's
 * been promoted instead of the standard CDC Ethernet.  The published RNDIS
@@ -67,22 +66,6 @@
 *   - MS-Windows drivers sometimes emit undocumented requests.
 */

-static unsigned int rndis_dl_max_pkt_per_xfer = 10;
-module_param(rndis_dl_max_pkt_per_xfer, uint, 0644);
-MODULE_PARM_DESC(rndis_dl_max_pkt_per_xfer,
-	"Maximum packets per transfer for DL aggregation");
-static unsigned int rndis_ul_max_pkt_per_xfer = 6;
-module_param(rndis_ul_max_pkt_per_xfer, uint, 0644);
-MODULE_PARM_DESC(rndis_ul_max_pkt_per_xfer,
-	"Maximum packets per transfer for UL aggregation");
-static unsigned int f_rndis_debug;
-module_param(f_rndis_debug, uint, 0644);
-MODULE_PARM_DESC(f_rndis_debug,
-		"f_rndis debug flag");
-#define F_RNDIS_DBG(fmt, args...) \
-	pr_notice("F_RNDIS,%s, " fmt, __func__, ## args)
-static struct f_rndis *_rndis;
-static spinlock_t rndis_lock;
 struct f_rndis {
 	struct gether			port;
 	u8				ctrl_id, data_id;
@@ -90,7 +73,6 @@ struct f_rndis {
 	u32				vendorID;
 	const char			*manufacturer;
 	struct rndis_params		*params;
-	int				config;

 	struct usb_ep			*notify;
 	struct usb_request		*notify_req;
@@ -133,9 +115,9 @@ static struct usb_interface_descriptor rndis_control_intf = {
 	/* .bInterfaceNumber = DYNAMIC */
 	/* status endpoint is optional; this could be patched later */
 	.bNumEndpoints =	1,
-	.bInterfaceClass =	USB_CLASS_WIRELESS_CONTROLLER,
-	.bInterfaceSubClass =	0x01,
-	.bInterfaceProtocol =	0x03,
+	.bInterfaceClass =	USB_CLASS_COMM,
+	.bInterfaceSubClass =   USB_CDC_SUBCLASS_ACM,
+	.bInterfaceProtocol =   USB_CDC_ACM_PROTO_VENDOR,
 	/* .iInterface = DYNAMIC */
 };

@@ -194,9 +176,9 @@ rndis_iad_descriptor = {

 	.bFirstInterface =	0, /* XXX, hardcoded */
 	.bInterfaceCount = 	2,	// control + data
-	.bFunctionClass =	USB_CLASS_WIRELESS_CONTROLLER,
-	.bFunctionSubClass =	0x01,
-	.bFunctionProtocol =	0x03,
+	.bFunctionClass =	USB_CLASS_COMM,
+	.bFunctionSubClass =	USB_CDC_SUBCLASS_ETHERNET,
+	.bFunctionProtocol =	USB_CDC_PROTO_NONE,
 	/* .iFunction = DYNAMIC */
 };

@@ -341,7 +323,6 @@ static struct usb_ss_ep_comp_descriptor ss_bulk_comp_desc = {
 	/* the following 2 values can be tweaked if necessary */
 	/* .bMaxBurst =		0, */
 	/* .bmAttributes =	0, */
-	.bMaxBurst =		4,
 };

 static struct usb_descriptor_header *eth_ss_function[] = {
@@ -390,35 +371,15 @@ static struct sk_buff *rndis_add_header(struct gether *port,
 					struct sk_buff *skb)
 {
 	struct sk_buff *skb2;
-	struct rndis_packet_msg_type *header = NULL;
-	struct f_rndis *rndis = func_to_rndis(&port->func);

-	if (rndis->port.multi_pkt_xfer) {
-		if (port->header) {
-			header = port->header;
-			memset(header, 0, sizeof(*header));
-			header->MessageType = cpu_to_le32(RNDIS_MSG_PACKET);
-			header->MessageLength = cpu_to_le32(skb->len +
-				sizeof(*header));
-			header->DataOffset = cpu_to_le32(36);
-			header->DataLength = cpu_to_le32(skb->len);
-			pr_debug("MessageLength:%d DataLength:%d\n",
-				header->MessageLength,
-				header->DataLength);
-			return skb;
-		}
-		pr_notice("RNDIS header is NULL.\n");
+	if (!skb)
 		return NULL;

-	} else {
-		skb2 = skb_realloc_headroom(skb,
-		sizeof(struct rndis_packet_msg_type));
-		if (skb2)
-			rndis_add_hdr(skb2);
+	skb2 = skb_realloc_headroom(skb, sizeof(struct rndis_packet_msg_type));
+	rndis_add_hdr(skb2);

-		dev_kfree_skb(skb);
-		return skb2;
-	}
+	dev_kfree_skb(skb);
+	return skb2;
 }

 static void rndis_response_available(void *_rndis)
@@ -449,24 +410,10 @@ static void rndis_response_available(void *_rndis)

 static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req)
 {
-	struct f_rndis			*rndis;
+	struct f_rndis			*rndis = req->context;
+	struct usb_composite_dev	*cdev = rndis->port.func.config->cdev;
 	int				status = req->status;
-	struct usb_composite_dev	*cdev;
-	struct usb_ep *notify_ep;

-	spin_lock(&rndis_lock);
-	rndis = _rndis;
-	if (!rndis || !rndis->notify) {
-		pr_notice("%s():rndis is NULL.\n", __func__);
-		spin_unlock(&rndis_lock);
-		return;
-	}
-	if (!rndis->port.func.config || !rndis->port.func.config->cdev) {
-		pr_notice("%s(): cdev or config is NULL.\n", __func__);
-		spin_unlock(&rndis_lock);
-		return;
-	}
-	cdev = rndis->port.func.config->cdev;
 	/* after TX:
 	 *  - USB_CDC_GET_ENCAPSULATED_RESPONSE (ep0/control)
 	 *  - RNDIS_RESPONSE_AVAILABLE (status/irq)
@@ -476,7 +423,7 @@ static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req)
 	case -ESHUTDOWN:
 		/* connection gone */
 		atomic_set(&rndis->notify_count, 0);
-		goto out;
+		break;
 	default:
 		DBG(cdev, "RNDIS %s response error %d, %d/%d\n",
 			ep->name, status,
@@ -484,73 +431,34 @@ static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req)
 		/* FALLTHROUGH */
 	case 0:
 		if (ep != rndis->notify)
-			goto out;
+			break;

 		/* handle multiple pending RNDIS_RESPONSE_AVAILABLE
 		 * notifications by resending until we're done
 		 */
 		if (atomic_dec_and_test(&rndis->notify_count))
-			goto out;
-		notify_ep = rndis->notify;
-		spin_unlock(&rndis_lock);
-		status = usb_ep_queue(notify_ep, req, GFP_ATOMIC);
+			break;
+		status = usb_ep_queue(rndis->notify, req, GFP_ATOMIC);
 		if (status) {
-			spin_lock(&rndis_lock);
-			if (!_rndis)
-				goto out;
 			atomic_dec(&rndis->notify_count);
 			DBG(cdev, "notify/1 --> %d\n", status);
-			spin_unlock(&rndis_lock);
 		}
-		return;
+		break;
 	}
-out:
-	spin_unlock(&rndis_lock);
 }

 static void rndis_command_complete(struct usb_ep *ep, struct usb_request *req)
 {
-	struct f_rndis			*rndis;
-	struct usb_composite_dev	*cdev;
+	struct f_rndis			*rndis = req->context;
 	int				status;
-	rndis_init_msg_type		*buf;

-	spin_lock(&rndis_lock);
-	rndis = _rndis;
-	if (!rndis || !rndis->notify) {
-		pr_notice("%s():rndis is NULL.\n", __func__);
-		spin_unlock(&rndis_lock);
-		return;
-	}
-	if (!rndis->port.func.config || !rndis->port.func.config->cdev) {
-		pr_notice("%s(): cdev or config is NULL.\n", __func__);
-		spin_unlock(&rndis_lock);
-		return;
-	}
-	cdev = rndis->port.func.config->cdev;
 	/* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */
 //	spin_lock(&dev->lock);
 	status = rndis_msg_parser(rndis->params, (u8 *) req->buf);
 	if (status < 0)
 		pr_err("RNDIS command error %d, %d/%d\n",
 			status, req->actual, req->length);
-	buf = (rndis_init_msg_type *)req->buf;
-	if (buf->MessageType == RNDIS_MSG_INIT) {
-		if (buf->MaxTransferSize > 2048) {
-			rndis->port.multi_pkt_xfer = 1;
-			rndis->port.dl_max_transfer_len = buf->MaxTransferSize;
-			gether_update_dl_max_xfer_size(&rndis->port,
-					rndis->port.dl_max_transfer_len);
-		} else
-			rndis->port.multi_pkt_xfer = 0;
-		pr_info("%s: MaxTransferSize: %d : Multi_pkt_txr: %s\n",
-				__func__, buf->MaxTransferSize,
-				rndis->port.multi_pkt_xfer ? "enabled" :
-							    "disabled");
-		if (rndis_dl_max_pkt_per_xfer <= 1)
-			rndis->port.multi_pkt_xfer = 0;
-	}
-	spin_unlock(&rndis_lock);
+//	spin_unlock(&dev->lock);
 }

 static int
@@ -563,12 +471,6 @@ rndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
 	u16			w_index = le16_to_cpu(ctrl->wIndex);
 	u16			w_value = le16_to_cpu(ctrl->wValue);
 	u16			w_length = le16_to_cpu(ctrl->wLength);
-	spin_lock(&rndis_lock);
-	if (!rndis || !rndis->notify) {
-		pr_notice("%s():rndis is NULL.\n", __func__);
-		spin_unlock(&rndis_lock);
-		return -EFAULT;
-	}

 	/* composite driver infrastructure handles everything except
 	 * CDC class messages; interface activation uses set_alt().
@@ -596,8 +498,6 @@ rndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
 		else {
 			u8 *buf;
 			u32 n;
-			u32 MsgType, MsgLength, MsgID;
-			__le32 *tmp;

 			/* return the result */
 			buf = rndis_get_next_response(rndis->params, &n);
@@ -605,10 +505,6 @@ rndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
 				memcpy(req->buf, buf, n);
 				req->complete = rndis_response_complete;
 				req->context = rndis;
-				tmp = (__le32 *)buf;
-				MsgType   = get_unaligned_le32(tmp++);
-				MsgLength = get_unaligned_le32(tmp++);
-				MsgID = get_unaligned_le32(tmp++);
 				rndis_free_response(rndis->params, buf);
 				value = n;
 			}
@@ -630,13 +526,10 @@ invalid:
 			w_value, w_index, w_length);
 		req->zero = (value < w_length);
 		req->length = value;
-		spin_unlock(&rndis_lock);
 		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
-		spin_lock(&rndis_lock);
 		if (value < 0)
 			ERROR(cdev, "rndis response on err %d\n", value);
 	}
-	spin_unlock(&rndis_lock);

 	/* device either stalls (value < 0) or reports success */
 	return value;
@@ -655,7 +548,6 @@ static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 		usb_ep_disable(rndis->notify);

 		if (!rndis->notify->desc) {
-			F_RNDIS_DBG("init rndis ctrl %d\n", intf);
 			VDBG(cdev, "init rndis ctrl %d\n", intf);
 			if (config_ep_by_speed(cdev->gadget, f, rndis->notify))
 				goto fail;
@@ -718,18 +610,17 @@ static void rndis_disable(struct usb_function *f)
 {
 	struct f_rndis		*rndis = func_to_rndis(f);
 	struct usb_composite_dev *cdev = f->config->cdev;
-	unsigned long flags;

 	if (!rndis->notify->enabled)
 		return;

 	DBG(cdev, "rndis deactivated\n");
-	spin_lock_irqsave(&rndis_lock, flags);
+
 	rndis_uninit(rndis->params);
-	spin_unlock_irqrestore(&rndis_lock, flags);
 	gether_disconnect(&rndis->port);

 	usb_ep_disable(rndis->notify);
+	rndis->notify->desc = NULL;
 }

 /*-------------------------------------------------------------------------*/
@@ -746,7 +637,6 @@ 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;

-	F_RNDIS_DBG("\n");
 	DBG(cdev, "%s\n", __func__);

 	rndis_set_param_medium(rndis->params, RNDIS_MEDIUM_802_3,
@@ -758,7 +648,6 @@ static void rndis_close(struct gether *geth)
 {
 	struct f_rndis		*rndis = func_to_rndis(&geth->func);

-	F_RNDIS_DBG("\n");
 	DBG(geth->func.config->cdev, "%s\n", __func__);

 	rndis_set_param_medium(rndis->params, RNDIS_MEDIUM_802_3, 0);
@@ -801,6 +690,9 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)
 		f->os_desc_table[0].os_desc = &rndis_opts->rndis_os_desc;
 	}

+	rndis_iad_descriptor.bFunctionClass = rndis_opts->class;
+	rndis_iad_descriptor.bFunctionSubClass = rndis_opts->subclass;
+	rndis_iad_descriptor.bFunctionProtocol = rndis_opts->protocol;

 	/*
 	 * in drivers/usb/gadget/configfs.c:configfs_composite_bind()
@@ -809,14 +701,12 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)
 	 * with list_for_each_entry, so we assume no race condition
 	 * with regard to rndis_opts->bound access
 	 */
-	if (rndis_opts) {
-		if (!rndis_opts->bound) {
-			gether_set_gadget(rndis_opts->net, cdev->gadget);
-			status = gether_register_netdev(rndis_opts->net);
-			if (status)
-				goto fail;
-			rndis_opts->bound = true;
-		}
+	if (!rndis_opts->bound) {
+		gether_set_gadget(rndis_opts->net, cdev->gadget);
+		status = gether_register_netdev(rndis_opts->net);
+		if (status)
+			goto fail;
+		rndis_opts->bound = true;
 	}

 	us = usb_gstrings_attach(cdev, rndis_strings,
@@ -879,12 +769,7 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)
 	rndis->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL);
 	if (!rndis->notify_req)
 		goto fail;
-#if defined(CONFIG_64BIT) && defined(CONFIG_MTK_LM_MODE)
-	rndis->notify_req->buf = kmalloc(STATUS_BYTECOUNT,
-					GFP_KERNEL | GFP_DMA);
-#else
 	rndis->notify_req->buf = kmalloc(STATUS_BYTECOUNT, GFP_KERNEL);
-#endif
 	if (!rndis->notify_req->buf)
 		goto fail;
 	rndis->notify_req->length = STATUS_BYTECOUNT;
@@ -913,7 +798,6 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)

 	rndis_set_param_medium(rndis->params, RNDIS_MEDIUM_802_3, 0);
 	rndis_set_host_mac(rndis->params, rndis->ethaddr);
-	rndis_set_max_pkt_xfer(rndis->params, rndis_ul_max_pkt_per_xfer);

 	if (rndis->manufacturer && rndis->vendorID &&
 			rndis_set_param_vendor(rndis->params, rndis->vendorID,
@@ -927,7 +811,7 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)
 	 * until we're activated via set_alt().
 	 */

-	INFO(cdev, "RNDIS: %s speed IN/%s OUT/%s NOTIFY/%s\n",
+	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,
@@ -985,11 +869,23 @@ USB_ETHERNET_CONFIGFS_ITEM_ATTR_QMULT(rndis);
 /* f_rndis_opts_ifname */
 USB_ETHERNET_CONFIGFS_ITEM_ATTR_IFNAME(rndis);

+/* f_rndis_opts_class */
+USB_ETHER_CONFIGFS_ITEM_ATTR_U8_RW(rndis, class);
+
+/* f_rndis_opts_subclass */
+USB_ETHER_CONFIGFS_ITEM_ATTR_U8_RW(rndis, subclass);
+
+/* f_rndis_opts_protocol */
+USB_ETHER_CONFIGFS_ITEM_ATTR_U8_RW(rndis, protocol);
+
 static struct configfs_attribute *rndis_attrs[] = {
 	&rndis_opts_attr_dev_addr,
 	&rndis_opts_attr_host_addr,
 	&rndis_opts_attr_qmult,
 	&rndis_opts_attr_ifname,
+	&rndis_opts_attr_class,
+	&rndis_opts_attr_subclass,
+	&rndis_opts_attr_protocol,
 	NULL,
 };

@@ -1029,7 +925,7 @@ static struct usb_function_instance *rndis_alloc_inst(void)

 	mutex_init(&opts->lock);
 	opts->func_inst.free_func_inst = rndis_free_inst;
-	opts->net = gether_setup_name_default("rndis");
+	opts->net = gether_setup_default();
 	if (IS_ERR(opts->net)) {
 		struct net_device *net = opts->net;
 		kfree(opts);
@@ -1037,6 +933,9 @@ static struct usb_function_instance *rndis_alloc_inst(void)
 	}
 	INIT_LIST_HEAD(&opts->rndis_os_desc.ext_prop);

+	opts->class = rndis_iad_descriptor.bFunctionClass;
+	opts->subclass = rndis_iad_descriptor.bFunctionSubClass;
+	opts->protocol = rndis_iad_descriptor.bFunctionProtocol;

 	descs[0] = &opts->rndis_os_desc;
 	names[0] = "rndis";
@@ -1058,15 +957,11 @@ static void rndis_free(struct usb_function *f)
 {
 	struct f_rndis *rndis;
 	struct f_rndis_opts *opts;
-	unsigned long flags;

 	rndis = func_to_rndis(f);
 	rndis_deregister(rndis->params);
 	opts = container_of(f->fi, struct f_rndis_opts, func_inst);
-	spin_lock_irqsave(&rndis_lock, flags);
 	kfree(rndis);
-	_rndis = NULL;
-	spin_unlock_irqrestore(&rndis_lock, flags);
 	mutex_lock(&opts->lock);
 	opts->refcnt--;
 	mutex_unlock(&opts->lock);
@@ -1095,7 +990,6 @@ static struct usb_function *rndis_alloc(struct usb_function_instance *fi)
 	if (!rndis)
 		return ERR_PTR(-ENOMEM);

-	_rndis = rndis;
 	opts = container_of(fi, struct f_rndis_opts, func_inst);
 	mutex_lock(&opts->lock);
 	opts->refcnt++;
@@ -1113,8 +1007,6 @@ static struct usb_function *rndis_alloc(struct usb_function_instance *fi)
 	rndis->port.header_len = sizeof(struct rndis_packet_msg_type);
 	rndis->port.wrap = rndis_add_header;
 	rndis->port.unwrap = rndis_rm_hdr;
-	rndis->port.ul_max_pkts_per_xfer = rndis_ul_max_pkt_per_xfer;
-	rndis->port.dl_max_pkts_per_xfer = rndis_dl_max_pkt_per_xfer;

 	rndis->port.func.name = "rndis";
 	/* descriptors are per-instance copies */
@@ -1124,7 +1016,6 @@ static struct usb_function *rndis_alloc(struct usb_function_instance *fi)
 	rndis->port.func.setup = rndis_setup;
 	rndis->port.func.disable = rndis_disable;
 	rndis->port.func.free_func = rndis_free;
-	spin_lock_init(&rndis_lock);

 	params = rndis_register(rndis_response_available, rndis);
 	if (IS_ERR(params)) {
--- a/drivers/usb/gadget/function/rndis.c
+++ b/drivers/usb/gadget/function/rndis.c
@@ -39,15 +39,7 @@

 #include "rndis.h"

-int rndis_ul_max_pkt_per_xfer_rcvd;
-module_param(rndis_ul_max_pkt_per_xfer_rcvd, int, 0444);
-MODULE_PARM_DESC(rndis_ul_max_pkt_per_xfer_rcvd,
-		"Max num of REMOTE_NDIS_PACKET_MSGs received in a single transfer");

-int rndis_ul_max_xfer_size_rcvd;
-module_param(rndis_ul_max_xfer_size_rcvd, int, 0444);
-MODULE_PARM_DESC(rndis_ul_max_xfer_size_rcvd,
-		"Max size of bus transfer received");
 /* The driver for your USB chip needs to support ep0 OUT to work with
 * RNDIS, plus all three CDC Ethernet endpoints (interrupt not optional).
 *
@@ -55,9 +47,13 @@ MODULE_PARM_DESC(rndis_ul_max_xfer_size_rcvd,
 * and will be happier if you provide the host_addr module parameter.
 */

+#if 0
 static int rndis_debug = 0;
-module_param(rndis_debug, uint, 0644);
+module_param (rndis_debug, int, 0);
 MODULE_PARM_DESC (rndis_debug, "enable debugging");
+#else
+#define rndis_debug		0
+#endif

 #ifdef CONFIG_USB_GADGET_DEBUG_FILES

@@ -168,7 +164,6 @@ static const u32 oid_supported_list[] = {
 #endif	/* RNDIS_PM */
 };

-#define RNDIS_DBG(fmt, args...) pr_notice("RNDIS,%s, " fmt, __func__, ## args)

 /* NDIS Functions */
 static int gen_ndis_query_resp(struct rndis_params *params, u32 OID, u8 *buf,
@@ -205,8 +200,6 @@ static int gen_ndis_query_resp(struct rndis_params *params, u32 OID, u8 *buf,

 	net = params->dev;
 	stats = dev_get_stats(net, &temp);
-	if (rndis_debug)
-		RNDIS_DBG("OID is 0x%x\n", OID);

 	switch (OID) {

@@ -333,9 +326,6 @@ static int gen_ndis_query_resp(struct rndis_params *params, u32 OID, u8 *buf,
 		if (rndis_debug > 1)
 			pr_debug("%s: RNDIS_OID_GEN_MEDIA_CONNECT_STATUS\n", __func__);
 		*outbuf = cpu_to_le32(params->media_state);
-	if (rndis_debug)
-		RNDIS_DBG("OID_GEN_MEDIA_CONNECT_STATUS, media_state %d\n",
-					params->media_state);
 		retval = 0;
 		break;

@@ -480,14 +470,10 @@ static int gen_ndis_query_resp(struct rndis_params *params, u32 OID, u8 *buf,
 		break;

 	default:
-		pr_debug("%s: query unknown OID 0x%08X\n",
-			 __func__, OID);
+		pr_warn("%s: query unknown OID 0x%08X\n", __func__, OID);
 	}
-	if (retval < 0) {
+	if (retval < 0)
 		length = 0;
-		RNDIS_DBG("%s, retval is %d\n",
-				__func__, retval);
-	}

 	resp->InformationBufferLength = cpu_to_le32(length);
 	r->length = length + sizeof(*resp);
@@ -517,8 +503,6 @@ static int gen_ndis_set_resp(struct rndis_params *params, u32 OID,
 				get_unaligned_le32(&buf[i + 12]));
 		}
 	}
-	if (rndis_debug)
-		RNDIS_DBG("OID is 0x%x\n", OID);

 	switch (OID) {
 	case RNDIS_OID_GEN_CURRENT_PACKET_FILTER:
@@ -561,8 +545,6 @@ static int gen_ndis_set_resp(struct rndis_params *params, u32 OID,
 			__func__, OID, buf_len);
 	}

-	if (retval)
-		RNDIS_DBG("retval is %d\n", retval);
 	return retval;
 }

@@ -592,12 +574,12 @@ static int rndis_init_response(struct rndis_params *params,
 	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(params->max_pkt_per_xfer);
-	resp->MaxTransferSize = cpu_to_le32(params->max_pkt_per_xfer *
-		(params->dev->mtu
+	resp->MaxPacketsPerTransfer = cpu_to_le32(1);
+	resp->MaxTransferSize = cpu_to_le32(
+		  params->dev->mtu
 		+ sizeof(struct ethhdr)
 		+ sizeof(struct rndis_packet_msg_type)
-		+ 22));
+		+ 22);
 	resp->PacketAlignmentFactor = cpu_to_le32(0);
 	resp->AFListOffset = cpu_to_le32(0);
 	resp->AFListSize = cpu_to_le32(0);
@@ -624,10 +606,8 @@ static int rndis_query_response(struct rndis_params *params,
 	 */
 	r = rndis_add_response(params,
 		sizeof(oid_supported_list) + sizeof(rndis_query_cmplt_type));
-	if (!r) {
-		RNDIS_DBG("rndis_add_response return NULL\n");
+	if (!r)
 		return -ENOMEM;
-	}
 	resp = (rndis_query_cmplt_type *)r->buf;

 	resp->MessageType = cpu_to_le32(RNDIS_MSG_QUERY_C);
@@ -665,10 +645,8 @@ static int rndis_set_response(struct rndis_params *params,
 			return -EINVAL;

 	r = rndis_add_response(params, sizeof(rndis_set_cmplt_type));
-	if (!r) {
-		pr_info("%s, rndis_add_response return NULL\n", __func__);
+	if (!r)
 		return -ENOMEM;
-	}
 	resp = (rndis_set_cmplt_type *)r->buf;

 #ifdef	VERBOSE_DEBUG
@@ -676,8 +654,9 @@ static int rndis_set_response(struct rndis_params *params,
 	pr_debug("%s: Offset: %d\n", __func__, BufOffset);
 	pr_debug("%s: InfoBuffer: ", __func__);

-	for (i = 0; i < BufLength; i++)
+	for (i = 0; i < BufLength; i++) {
 		pr_debug("%02x ", *(((u8 *) buf) + i + 8 + BufOffset));
+	}

 	pr_debug("\n");
 #endif
@@ -700,15 +679,12 @@ static int rndis_reset_response(struct rndis_params *params,
 {
 	rndis_reset_cmplt_type *resp;
 	rndis_resp_t *r;
-
-	u32 length;
 	u8 *xbuf;
+	u32 length;

-	RNDIS_DBG("reset, clean old response\n");
 	/* drain the response queue */
 	while ((xbuf = rndis_get_next_response(params, &length)))
 		rndis_free_response(params, xbuf);
-	rndis_test_reset_msg_cnt++;

 	r = rndis_add_response(params, sizeof(rndis_reset_cmplt_type));
 	if (!r)
@@ -734,10 +710,8 @@ static int rndis_keepalive_response(struct rndis_params *params,
 	/* host "should" check only in RNDIS_DATA_INITIALIZED state */

 	r = rndis_add_response(params, sizeof(rndis_keepalive_cmplt_type));
-	if (!r) {
-		RNDIS_DBG("rndis_add_response return NULL\n");
+	if (!r)
 		return -ENOMEM;
-	}
 	resp = (rndis_keepalive_cmplt_type *)r->buf;

 	resp->MessageType = cpu_to_le32(RNDIS_MSG_KEEPALIVE_C);
@@ -816,7 +790,7 @@ EXPORT_SYMBOL_GPL(rndis_set_host_mac);
 */
 int rndis_msg_parser(struct rndis_params *params, u8 *buf)
 {
-	u32 MsgType, MsgLength, MsgID;
+	u32 MsgType, MsgLength;
 	__le32 *tmp;

 	if (!buf)
@@ -825,11 +799,6 @@ int rndis_msg_parser(struct rndis_params *params, u8 *buf)
 	tmp = (__le32 *)buf;
 	MsgType   = get_unaligned_le32(tmp++);
 	MsgLength = get_unaligned_le32(tmp++);
-	MsgID = get_unaligned_le32(tmp++);
-	if (rndis_debug)
-		RNDIS_DBG("MsgType is %d, RequestID is 0x%x\n",
-				MsgType, MsgID);
-	rndis_test_last_msg_id = MsgID;

 	if (!params)
 		return -ENOTSUPP;
@@ -886,28 +855,11 @@ int rndis_msg_parser(struct rndis_params *params, u8 *buf)
 		 */
 		pr_warn("%s: unknown RNDIS message 0x%08X len %d\n",
 			__func__, MsgType, MsgLength);
-		{
-			unsigned int i;
-
-			for (i = 0; i < MsgLength; i += 16) {
-				pr_debug("%03d\n"
-						"%02x %02x %02x %02x\n"
-						"%02x %02x %02x %02x\n"
-						"%02x %02x %02x %02x\n"
-						"%02x %02x %02x %02x\n",
-						i, buf[i], buf[i+1],
-						buf[i+2], buf[i+3],
-						buf[i+4], buf[i+5],
-						buf[i+6], buf[i+7],
-						buf[i+8], buf[i+9],
-						buf[i+10], buf[i+11],
-						buf[i+12], buf[i+13],
-						buf[i+14], buf[i+15]);
-			}
-		}
-		/* print_hex_dump_bytes(__func__, DUMP_PREFIX_OFFSET,
-		 *		     buf, MsgLength);
-		 */
+		/* Garbled message can be huge, so limit what we display */
+		if (MsgLength > 16)
+			MsgLength = 16;
+		print_hex_dump_bytes(__func__, DUMP_PREFIX_OFFSET,
+				     buf, MsgLength);
 		break;
 	}

@@ -970,7 +922,6 @@ struct rndis_params *rndis_register(void (*resp_avail)(void *v), void *v)
 	params->media_state = RNDIS_MEDIA_STATE_DISCONNECTED;
 	params->resp_avail = resp_avail;
 	params->v = v;
-	params->max_pkt_per_xfer = 1;
 	INIT_LIST_HEAD(&params->resp_queue);
 	spin_lock_init(&params->resp_lock);
 	pr_debug("%s: configNr = %d\n", __func__, i);
@@ -1015,8 +966,6 @@ int rndis_set_param_dev(struct rndis_params *params, struct net_device *dev,
 	params->dev = dev;
 	params->filter = cdc_filter;

-	rndis_ul_max_xfer_size_rcvd = 0;
-	rndis_ul_max_pkt_per_xfer_rcvd = 0;
 	return 0;
 }
 EXPORT_SYMBOL_GPL(rndis_set_param_dev);
@@ -1049,20 +998,13 @@ int rndis_set_param_medium(struct rndis_params *params, u32 medium, u32 speed)
 }
 EXPORT_SYMBOL_GPL(rndis_set_param_medium);

-void rndis_set_max_pkt_xfer(struct rndis_params *params, u8 max_pkt_per_xfer)
-{
-	pr_debug("%s:\n", __func__);
-
-	params->max_pkt_per_xfer = max_pkt_per_xfer;
-}
-
 void rndis_add_hdr(struct sk_buff *skb)
 {
 	struct rndis_packet_msg_type *header;

 	if (!skb)
 		return;
-	header = (void *)skb_push(skb, sizeof(*header));
+	header = skb_push(skb, sizeof(*header));
 	memset(header, 0, sizeof *header);
 	header->MessageType = cpu_to_le32(RNDIS_MSG_PACKET);
 	header->MessageLength = cpu_to_le32(skb->len);
@@ -1111,8 +1053,6 @@ static rndis_resp_t *rndis_add_response(struct rndis_params *params, u32 length)
 {
 	rndis_resp_t *r;

-	if (rndis_debug > 2)
-		RNDIS_DBG("\n");
 	/* NOTE: this gets copied into ether.c USB_BUFSIZ bytes ... */
 	r = kmalloc(sizeof(rndis_resp_t) + length, GFP_ATOMIC);
 	if (!r) return NULL;
@@ -1131,67 +1071,23 @@ int rndis_rm_hdr(struct gether *port,
 			struct sk_buff *skb,
 			struct sk_buff_head *list)
 {
-	int num_pkts = 1;
-
-	if (skb->len > rndis_ul_max_xfer_size_rcvd)
-		rndis_ul_max_xfer_size_rcvd = skb->len;
-	while (skb->len) {
-		struct rndis_packet_msg_type *hdr;
-		struct sk_buff          *skb2;
-		u32             msg_len, data_offset, data_len;
+	/* tmp points to a struct rndis_packet_msg_type */
+	__le32 *tmp = (void *)skb->data;

 	/* MessageType, MessageLength */
-		if (skb->len == 1) {
-			dev_kfree_skb_any(skb);
-			return 0;
-		}
-		if (skb->len < sizeof(*hdr)) {
-			pr_info("invalid rndis pkt: skblen:%u hdr_len:%zu",
-					skb->len, sizeof(*hdr));
+	if (cpu_to_le32(RNDIS_MSG_PACKET)
+			!= get_unaligned(tmp++)) {
 		dev_kfree_skb_any(skb);
 		return -EINVAL;
 	}
+	tmp++;

-		hdr = (void *)skb->data;
-		msg_len = le32_to_cpu(hdr->MessageLength);
-		data_offset = le32_to_cpu(hdr->DataOffset);
-		data_len = le32_to_cpu(hdr->DataLength);
-
-		if (skb->len < msg_len ||
-				((data_offset + data_len + 8) > msg_len)) {
-			pr_info("invalid rndis message: %d/%d/%d/%d, len:%d\n",
-					le32_to_cpu(hdr->MessageType),
-					msg_len, data_offset,
-					data_len, skb->len);
+	/* DataOffset, DataLength */
+	if (!skb_pull(skb, get_unaligned_le32(tmp++) + 8)) {
 		dev_kfree_skb_any(skb);
 		return -EOVERFLOW;
 	}
-		if (le32_to_cpu(hdr->MessageType) != RNDIS_MSG_PACKET) {
-			pr_info("invalid rndis message: %d/%d/%d/%d, len:%d\n",
-					le32_to_cpu(hdr->MessageType),
-					msg_len, data_offset, data_len,
-					skb->len);
-			dev_kfree_skb_any(skb);
-			return -EINVAL;
-		}
-		skb_pull(skb, data_offset + 8);
-		if (msg_len == skb->len) {
-			skb_trim(skb, data_len);
-			break;
-		}
-		skb2 = skb_clone(skb, GFP_ATOMIC);
-		if (!skb2) {
-			pr_info("%s:skb clone failed\n", __func__);
-			dev_kfree_skb_any(skb);
-			return -ENOMEM;
-		}
-		skb_pull(skb, msg_len - sizeof(*hdr));
-		skb_trim(skb2, data_len);
-		skb_queue_tail(list, skb2);
-		num_pkts++;
-	}
-	if (num_pkts > rndis_ul_max_pkt_per_xfer_rcvd)
-		rndis_ul_max_pkt_per_xfer_rcvd = num_pkts;
+	skb_trim(skb, get_unaligned_le32(tmp++));

 	skb_queue_tail(list, skb);
 	return 0;
@@ -1212,9 +1108,7 @@ static int rndis_proc_show(struct seq_file *m, void *v)
 			 "speed     : %d\n"
 			 "cable     : %s\n"
 			 "vendor ID : 0x%08X\n"
-			 "vendor    : %s\n"
-			 "ul-max-xfer-size:%d max-xfer-size-rcvd: %d\n"
-			 "ul-max-pkts-per-xfer:%d max-pkts-per-xfer-rcvd:%d\n",
+			 "vendor    : %s\n",
 			 param->confignr, (param->used) ? "y" : "n",
 			 ({ char *s = "?";
 			 switch (param->state) {
@@ -1228,13 +1122,7 @@ static int rndis_proc_show(struct seq_file *m, void *v)
 			 param->medium,
 			 (param->media_state) ? 0 : param->speed*100,
 			 (param->media_state) ? "disconnected" : "connected",
-			 param->vendorID, param->vendorDescr,
-			 param->max_pkt_per_xfer *
-				 (param->dev->mtu + sizeof(struct ethhdr) +
-				  sizeof(struct rndis_packet_msg_type) + 22),
-			 rndis_ul_max_xfer_size_rcvd,
-			 param->max_pkt_per_xfer,
-			 rndis_ul_max_pkt_per_xfer_rcvd);
+			 param->vendorID, param->vendorDescr);
 	return 0;
 }

@@ -1297,7 +1185,6 @@ static const struct file_operations rndis_proc_fops = {
 	.write		= rndis_proc_write,
 };

-define	NAME_TEMPLATE "driver/rndis-%03d"
+#define	NAME_TEMPLATE "driver/rndis-%03d"

-static struct proc_dir_entry *rndis_connect_state[RNDIS_MAX_CONFIGS];
 #endif /* CONFIG_USB_GADGET_DEBUG_FILES */
--- a/drivers/usb/gadget/function/rndis.h
+++ b/drivers/usb/gadget/function/rndis.h
@@ -170,7 +170,6 @@ typedef struct rndis_params {
 	struct net_device	*dev;

 	u32			vendorID;
-	u8			max_pkt_per_xfer;
 	const char		*vendorDescr;
 	void			(*resp_avail)(void *v);
 	void			*v;
@@ -188,7 +187,6 @@ int  rndis_set_param_vendor(struct rndis_params *params, u32 vendorID,
 			    const char *vendorDescr);
 int  rndis_set_param_medium(struct rndis_params *params, u32 medium,
 			     u32 speed);
-void rndis_set_max_pkt_xfer(struct rndis_params *params, u8 max_pkt_per_xfer);
 void rndis_add_hdr(struct sk_buff *skb);
 int rndis_rm_hdr(struct gether *port, struct sk_buff *skb,
 			struct sk_buff_head *list);
--- a/drivers/usb/gadget/function/u_ether.c
+++ b/drivers/usb/gadget/function/u_ether.c
--- a/drivers/usb/gadget/function/u_ether.h
+++ b/drivers/usb/gadget/function/u_ether.h
@@ -16,7 +16,7 @@
 #include <linux/usb/cdc.h>
 #include <linux/netdevice.h>

-#define QMULT_DEFAULT 50
+#define QMULT_DEFAULT 5

 /*
 * dev_addr: initial value
@@ -25,51 +25,18 @@
 */
 #define USB_ETHERNET_MODULE_PARAMETERS() \
 	static unsigned qmult = QMULT_DEFAULT;				\
-	module_param(qmult, uint, 0644);			\
+	module_param(qmult, uint, S_IRUGO|S_IWUSR);			\
 	MODULE_PARM_DESC(qmult, "queue length multiplier at high/super speed");\
 									\
 	static char *dev_addr;						\
-	module_param(dev_addr, charp, 0644);				\
+	module_param(dev_addr, charp, S_IRUGO);				\
 	MODULE_PARM_DESC(dev_addr, "Device Ethernet Address");		\
 									\
 	static char *host_addr;						\
-	module_param(host_addr, charp, 0644);			\
+	module_param(host_addr, charp, S_IRUGO);			\
 	MODULE_PARM_DESC(host_addr, "Host Ethernet Address")

-struct eth_dev {
-	spinlock_t		lock;
-	struct gether		*port_usb;
-	struct net_device	*net;
-	struct usb_gadget	*gadget;
-	spinlock_t		req_lock;	/* guard {tx}_reqs */
-	spinlock_t		reqrx_lock;	/* guard {rx}_reqs */
-	struct list_head	tx_reqs, rx_reqs;
-	atomic_t		tx_qlen;
-#define TX_REQ_THRESHOLD	1
-	int			no_tx_req_used;
-	int			tx_skb_hold_count;
-	u32			tx_req_bufsize;
-	struct sk_buff_head	rx_frames;
-	unsigned int		qmult;
-	unsigned int		header_len;
-	unsigned int		ul_max_pkts_per_xfer;
-	unsigned int		dl_max_pkts_per_xfer;
-	uint32_t		dl_max_xfer_size;
-	struct sk_buff		*(*wrap)(struct gether *link,
-			struct sk_buff *skb);
-	int			(*unwrap)(struct gether *link,
-						struct sk_buff *skb,
-						struct sk_buff_head *list);
-	struct work_struct	work;
-	struct work_struct	rx_work;
-	struct work_struct	rx_work1;
-	struct work_struct	rps_map_work;
-	unsigned long		todo;
-#define	WORK_RX_MEMORY		0
-	bool			zlp;
-	u8			host_mac[ETH_ALEN];
-	u8			dev_mac[ETH_ALEN];
-};
+struct eth_dev;

 /*
 * This represents the USB side of an "ethernet" link, managed by a USB
@@ -102,10 +69,6 @@ struct gether {
 	bool				is_fixed;
 	u32				fixed_out_len;
 	u32				fixed_in_len;
-	unsigned int		ul_max_pkts_per_xfer;
-	unsigned int		dl_max_pkts_per_xfer;
-	unsigned int		dl_max_transfer_len;
-	bool				multi_pkt_xfer;
 	bool				supports_multi_frame;
 	struct sk_buff			*(*wrap)(struct gether *port,
 						struct sk_buff *skb);
@@ -116,7 +79,6 @@ struct gether {
 	/* called on network open/close */
 	void				(*open)(struct gether *);
 	void				(*close)(struct gether *);
-	struct rndis_packet_msg_type	*header;
 };

 #define	DEFAULT_FILTER	(USB_CDC_PACKET_TYPE_BROADCAST \
@@ -287,7 +249,6 @@ void gether_cleanup(struct eth_dev *dev);
 /* connect/disconnect is handled by individual functions */
 struct net_device *gether_connect(struct gether *);
 void gether_disconnect(struct gether *);
-void gether_update_dl_max_xfer_size(struct gether *link, uint32_t s);

 /* Some controllers can't support CDC Ethernet (ECM) ... */
 static inline bool can_support_ecm(struct usb_gadget *gadget)
@@ -302,18 +263,4 @@ static inline bool can_support_ecm(struct usb_gadget *gadget)
 	return true;
 }

-extern unsigned int rndis_test_last_resp_id;
-extern unsigned int rndis_test_last_msg_id;
-extern unsigned long rndis_test_reset_msg_cnt;
-extern unsigned long rndis_test_rx_usb_in;
-extern unsigned long rndis_test_rx_net_out;
-extern unsigned long rndis_test_rx_nomem;
-extern unsigned long rndis_test_rx_error;
-extern unsigned long rndis_test_tx_net_in;
-extern unsigned long rndis_test_tx_busy;
-extern unsigned long rndis_test_tx_stop;
-extern unsigned long rndis_test_tx_nomem;
-extern unsigned long rndis_test_tx_usb_out;
-extern unsigned long rndis_test_tx_complete;
-extern void rx_fill(struct eth_dev *dev, gfp_t gfp_flags);
 #endif /* __U_ETHER_H */