diff --git a/device/linux-nokia-frt/00_symlinks.patch b/device/linux-nokia-frt/00_symlinks.patch new file mode 100644 index 000000000..b1916939e --- /dev/null +++ b/device/linux-nokia-frt/00_symlinks.patch @@ -0,0 +1,171 @@ +this patch contains required symlinks and includes +--- +diff --git a/drivers/misc/mediatek/btcvsd/inc/mt6735/AudioBTCVSDDef.h b/drivers/misc/mediatek/btcvsd/inc/mt6735/AudioBTCVSDDef.h +new file mode 120000 +index 000000000000..039aa8632a90 +--- /dev/null ++++ b/drivers/misc/mediatek/btcvsd/inc/mt6735/AudioBTCVSDDef.h +@@ -0,0 +1 @@ ++../../AudioBTCVSDDef.h +\ No newline at end of file +diff --git a/drivers/misc/mediatek/cmdq/v2/cmdq_def.h b/drivers/misc/mediatek/cmdq/v2/cmdq_def.h +index 9383c5860a00..b01dfddab473 100644 +--- a/drivers/misc/mediatek/cmdq/v2/cmdq_def.h ++++ b/drivers/misc/mediatek/cmdq/v2/cmdq_def.h +@@ -22,7 +22,7 @@ + #ifdef CMDQ_COMMON_ENG_SUPPORT + #include "cmdq_engine_common.h" + #else +-#include "cmdq_engine.h" ++#include "mt6735/cmdq_engine.h" + #endif + + #define CMDQ_SPECIAL_SUBSYS_ADDR (99) +diff --git a/drivers/misc/mediatek/ext_disp/extd_factory.c b/drivers/misc/mediatek/ext_disp/extd_factory.c +index 92c137980092..505dd793ab61 100644 +--- a/drivers/misc/mediatek/ext_disp/extd_factory.c ++++ b/drivers/misc/mediatek/ext_disp/extd_factory.c +@@ -17,7 +17,7 @@ + #include "extd_log.h" + #include "extd_factory.h" + #include "extd_info.h" +-#include "external_display.h" ++#include "mt6735m/external_display.h" + + #include "dpi_dvt_test.h" + +diff --git a/drivers/misc/mediatek/ext_disp/extd_multi_control.c b/drivers/misc/mediatek/ext_disp/extd_multi_control.c +index 52dd1f77b6b5..e6277c4eb37c 100644 +--- a/drivers/misc/mediatek/ext_disp/extd_multi_control.c ++++ b/drivers/misc/mediatek/ext_disp/extd_multi_control.c +@@ -16,8 +16,8 @@ + + #include "extd_multi_control.h" + #include "disp_drv_platform.h" +-#include "external_display.h" +-#include "extd_platform.h" ++#include "mt6735m/external_display.h" ++#include "mt6735m/extd_platform.h" + #include "extd_log.h" + #include "mtk_ovl.h" + +diff --git a/drivers/misc/mediatek/include/mt-plat/mt6735/include/mach/mt_gpufreq.h b/drivers/misc/mediatek/include/mt-plat/mt6735/include/mach/mt_gpufreq.h +new file mode 120000 +index 000000000000..878f8cd06d0d +--- /dev/null ++++ b/drivers/misc/mediatek/include/mt-plat/mt6735/include/mach/mt_gpufreq.h +@@ -0,0 +1 @@ ++../../../../../base/power/mt6735/mt_gpufreq.h +\ No newline at end of file +diff --git a/drivers/misc/mediatek/include/mt-plat/mt_sd.h b/drivers/misc/mediatek/include/mt-plat/mt_sd.h +new file mode 120000 +index 000000000000..578ca29d2b38 +--- /dev/null ++++ b/drivers/misc/mediatek/include/mt-plat/mt_sd.h +@@ -0,0 +1 @@ ++../../../../mmc/host/mediatek/mt6735/mt_sd.h +\ No newline at end of file +diff --git a/drivers/misc/mediatek/m4u/2.0/m4u_reg.h b/drivers/misc/mediatek/m4u/2.0/m4u_reg.h +new file mode 120000 +index 000000000000..8b49936c55bf +--- /dev/null ++++ b/drivers/misc/mediatek/m4u/2.0/m4u_reg.h +@@ -0,0 +1 @@ ++../mt6735/mt6735m/m4u_reg.h +\ No newline at end of file +diff --git a/drivers/misc/mediatek/m4u/mt6735/m4u_priv.h b/drivers/misc/mediatek/m4u/mt6735/m4u_priv.h +index ec1f9d6a2993..9b5fd8ba67d3 100644 +--- a/drivers/misc/mediatek/m4u/mt6735/m4u_priv.h ++++ b/drivers/misc/mediatek/m4u/mt6735/m4u_priv.h +@@ -25,9 +25,9 @@ + #endif + + #include "m4u.h" +-#include "m4u_reg.h" ++#include "mt6735m/m4u_reg.h" + #include "../2.0/m4u_pgtable.h" +-#include "m4u_platform.h" ++#include "mt6735m/m4u_platform.h" + + #define M4UMSG(string, args...) pr_err("M4U"string, ##args) + #define M4UINFO(string, args...) pr_debug("M4U"string, ##args) +diff --git a/drivers/misc/mediatek/uart/include/platform_uart.h b/drivers/misc/mediatek/uart/include/platform_uart.h +new file mode 120000 +index 000000000000..7850df5513d1 +--- /dev/null ++++ b/drivers/misc/mediatek/uart/include/platform_uart.h +@@ -0,0 +1 @@ ++../mt6735/platform_uart.h +\ No newline at end of file +diff --git a/drivers/misc/mediatek/video/include/ddp_mmp.h b/drivers/misc/mediatek/video/include/ddp_mmp.h +new file mode 120000 +index 000000000000..226e7f918f41 +--- /dev/null ++++ b/drivers/misc/mediatek/video/include/ddp_mmp.h +@@ -0,0 +1 @@ ++../mt6735/ddp_mmp.h +\ No newline at end of file +diff --git a/drivers/misc/mediatek/video/include/disp_debug.h b/drivers/misc/mediatek/video/include/disp_debug.h +new file mode 120000 +index 000000000000..f474a1e460ce +--- /dev/null ++++ b/drivers/misc/mediatek/video/include/disp_debug.h +@@ -0,0 +1 @@ ++../mt6735/disp_debug.h +\ No newline at end of file +diff --git a/drivers/misc/mediatek/video/include/disp_event.h b/drivers/misc/mediatek/video/include/disp_event.h +new file mode 120000 +index 000000000000..551dd22ee806 +--- /dev/null ++++ b/drivers/misc/mediatek/video/include/disp_event.h +@@ -0,0 +1 @@ ++../mt6735/disp_event.h +\ No newline at end of file +diff --git a/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_drv.h b/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_drv.h +new file mode 120000 +index 000000000000..611b18a27478 +--- /dev/null ++++ b/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_drv.h +@@ -0,0 +1 @@ ++../ddp_drv.h +\ No newline at end of file +diff --git a/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_dump.h b/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_dump.h +new file mode 120000 +index 000000000000..527ca2cc5745 +--- /dev/null ++++ b/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_dump.h +@@ -0,0 +1 @@ ++../ddp_dump.h +\ No newline at end of file +diff --git a/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_hal.h b/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_hal.h +new file mode 120000 +index 000000000000..4a859796c458 +--- /dev/null ++++ b/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_hal.h +@@ -0,0 +1 @@ ++../ddp_hal.h +\ No newline at end of file +diff --git a/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_info.h b/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_info.h +new file mode 120000 +index 000000000000..3902fed2f81c +--- /dev/null ++++ b/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_info.h +@@ -0,0 +1 @@ ++../ddp_info.h +\ No newline at end of file +diff --git a/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_path.h b/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_path.h +new file mode 120000 +index 000000000000..c2a88d4cbbcc +--- /dev/null ++++ b/drivers/misc/mediatek/video/mt6735/mt6735m/ddp_path.h +@@ -0,0 +1 @@ ++../ddp_path.h +\ No newline at end of file +diff --git a/drivers/misc/mediatek/video/mt6735/mt6735m/disp_assert_layer.h b/drivers/misc/mediatek/video/mt6735/mt6735m/disp_assert_layer.h +new file mode 120000 +index 000000000000..8eb3b6685798 +--- /dev/null ++++ b/drivers/misc/mediatek/video/mt6735/mt6735m/disp_assert_layer.h +@@ -0,0 +1 @@ ++../disp_assert_layer.h +\ No newline at end of file diff --git a/device/linux-nokia-frt/00_makefile_path.patch b/device/linux-nokia-frt/01_makefile_path.patch similarity index 100% rename from device/linux-nokia-frt/00_makefile_path.patch rename to device/linux-nokia-frt/01_makefile_path.patch diff --git a/device/linux-nokia-frt/01_drvgen_mk.patch b/device/linux-nokia-frt/02_drvgen_mk.patch similarity index 100% rename from device/linux-nokia-frt/01_drvgen_mk.patch rename to device/linux-nokia-frt/02_drvgen_mk.patch diff --git a/device/linux-nokia-frt/02_path_fixes.patch b/device/linux-nokia-frt/02_path_fixes.patch deleted file mode 100644 index e783bab37..000000000 --- a/device/linux-nokia-frt/02_path_fixes.patch +++ /dev/null @@ -1,60 +0,0 @@ -Fixes for wrong includes paths, probably missing symlinks ---- - -diff --git a/drivers/misc/mediatek/cmdq/v2/cmdq_def.h b/drivers/misc/mediatek/cmdq/v2/cmdq_def.h -index 9383c5860a00..b01dfddab473 100644 ---- a/drivers/misc/mediatek/cmdq/v2/cmdq_def.h -+++ b/drivers/misc/mediatek/cmdq/v2/cmdq_def.h -@@ -22,7 +22,7 @@ - #ifdef CMDQ_COMMON_ENG_SUPPORT - #include "cmdq_engine_common.h" - #else --#include "cmdq_engine.h" -+#include "mt6735/cmdq_engine.h" - #endif - - #define CMDQ_SPECIAL_SUBSYS_ADDR (99) -diff --git a/drivers/misc/mediatek/ext_disp/extd_factory.c b/drivers/misc/mediatek/ext_disp/extd_factory.c -index 92c137980092..505dd793ab61 100644 ---- a/drivers/misc/mediatek/ext_disp/extd_factory.c -+++ b/drivers/misc/mediatek/ext_disp/extd_factory.c -@@ -17,7 +17,7 @@ - #include "extd_log.h" - #include "extd_factory.h" - #include "extd_info.h" --#include "external_display.h" -+#include "mt6735m/external_display.h" - - #include "dpi_dvt_test.h" - -diff --git a/drivers/misc/mediatek/ext_disp/extd_multi_control.c b/drivers/misc/mediatek/ext_disp/extd_multi_control.c -index 52dd1f77b6b5..e6277c4eb37c 100644 ---- a/drivers/misc/mediatek/ext_disp/extd_multi_control.c -+++ b/drivers/misc/mediatek/ext_disp/extd_multi_control.c -@@ -16,8 +16,8 @@ - - #include "extd_multi_control.h" - #include "disp_drv_platform.h" --#include "external_display.h" --#include "extd_platform.h" -+#include "mt6735m/external_display.h" -+#include "mt6735m/extd_platform.h" - #include "extd_log.h" - #include "mtk_ovl.h" - -diff --git a/drivers/misc/mediatek/m4u/mt6735/m4u_priv.h b/drivers/misc/mediatek/m4u/mt6735/m4u_priv.h -index ec1f9d6a2993..9b5fd8ba67d3 100644 ---- a/drivers/misc/mediatek/m4u/mt6735/m4u_priv.h -+++ b/drivers/misc/mediatek/m4u/mt6735/m4u_priv.h -@@ -25,9 +25,9 @@ - #endif - - #include "m4u.h" --#include "m4u_reg.h" -+#include "mt6735m/m4u_reg.h" - #include "../2.0/m4u_pgtable.h" --#include "m4u_platform.h" -+#include "mt6735m/m4u_platform.h" - - #define M4UMSG(string, args...) pr_err("M4U"string, ##args) - #define M4UINFO(string, args...) pr_debug("M4U"string, ##args) diff --git a/device/linux-nokia-frt/03_vdsomunge_upstream.patch b/device/linux-nokia-frt/03_vdsomunge_upstream.patch index 20b14f914..528cc0c55 100644 --- a/device/linux-nokia-frt/03_vdsomunge_upstream.patch +++ b/device/linux-nokia-frt/03_vdsomunge_upstream.patch @@ -1,7 +1,5 @@ -Downstream version required various glibc functions, -this patch contains version from upstream kernel 4.19 +Fixes compilation under gcc8 without glibc --- - diff --git a/arch/arm/vdso/vdsomunge.c b/arch/arm/vdso/vdsomunge.c index 9005b07296c8..f6455273b2f8 100644 --- a/arch/arm/vdso/vdsomunge.c @@ -177,4 +175,4 @@ index 9005b07296c8..f6455273b2f8 100644 + fail("Failed to sync %s: %s\n", outfile, strerror(errno)); return EXIT_SUCCESS; - } + } \ No newline at end of file diff --git a/device/linux-nokia-frt/04_rndis.patch b/device/linux-nokia-frt/04_rndis.patch new file mode 100644 index 000000000..34d258795 --- /dev/null +++ b/device/linux-nokia-frt/04_rndis.patch @@ -0,0 +1,2028 @@ +This patch fixes ethernet gadget/rndis support so the phone is detected as usb device +and can assign ip to the PC, as well as allow for ssh connections through usb +--- +diff --git a/drivers/usb/gadget/function/f_rndis.c b/drivers/usb/gadget/function/f_rndis.c +index 4b7e1593c787..f13fc6a58565 100644 +--- a/drivers/usb/gadget/function/f_rndis.c ++++ b/drivers/usb/gadget/function/f_rndis.c +@@ -70,22 +70,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, S_IRUGO | S_IWUSR); +-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 = 1; +-module_param(rndis_ul_max_pkt_per_xfer, uint, S_IRUGO | S_IWUSR); +-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, S_IRUGO | S_IWUSR); +-MODULE_PARM_DESC(f_rndis_debug, +- "f_rndis debug flag"); +-#define F_RNDIS_DBG(fmt, args...) pr_debug("F_RNDIS,%s, " fmt, __func__, ## args) +- + struct f_rndis { + struct gether port; + u8 ctrl_id, data_id; +@@ -389,35 +373,13 @@ 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_err("RNDIS header is NULL.\n"); +- 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)); ++ if (skb2) ++ rndis_add_hdr(skb2); + +- dev_kfree_skb(skb); +- return skb2; +- } ++ dev_kfree_skb(skb); ++ return skb2; + } + + static void rndis_response_available(void *_rndis) +@@ -449,14 +411,9 @@ static void rndis_response_available(void *_rndis) + static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req) + { + struct f_rndis *rndis = req->context; +- struct usb_composite_dev *cdev; ++ struct usb_composite_dev *cdev = rndis->port.func.config->cdev; + int status = req->status; + +- if (!rndis->port.func.config || !rndis->port.func.config->cdev) +- return; +- +- cdev = rndis->port.func.config->cdev; +- + /* after TX: + * - USB_CDC_GET_ENCAPSULATED_RESPONSE (ep0/control) + * - RNDIS_RESPONSE_AVAILABLE (status/irq) +@@ -493,14 +450,7 @@ static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req) + static void rndis_command_complete(struct usb_ep *ep, struct usb_request *req) + { + struct f_rndis *rndis = req->context; +- struct usb_composite_dev *cdev; + int status; +- rndis_init_msg_type *buf; +- +- if (!rndis->port.func.config || !rndis->port.func.config->cdev) +- return; +- +- cdev = rndis->port.func.config->cdev; + + /* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */ + // spin_lock(&dev->lock); +@@ -508,24 +458,6 @@ static void rndis_command_complete(struct usb_ep *ep, struct usb_request *req) + 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(&dev->lock); + } + +@@ -543,9 +475,6 @@ rndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl) + /* composite driver infrastructure handles everything except + * CDC class messages; interface activation uses set_alt(). + */ +- if (f_rndis_debug) +- F_RNDIS_DBG("ctrl->bRequestType:0x%x, ctrl->bRequest:0x%x, w_index:0x%x, w_value:0x%x\n", +- ctrl->bRequestType , ctrl->bRequest, w_index, w_value); + switch ((ctrl->bRequestType << 8) | ctrl->bRequest) { + + /* RNDIS uses the CDC command encapsulation mechanism to implement +@@ -569,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->config, &n); +@@ -578,19 +505,8 @@ 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->config, buf); + value = n; +- +- if (f_rndis_debug) +- F_RNDIS_DBG("response MsgLength %d, msg type:0x%x, RequestID:0x%x\n", +- MsgLength, MsgType, MsgID); +- rndis_test_last_resp_id = MsgID; + } + /* else stalls ... spec says to avoid that */ + } +@@ -598,10 +514,6 @@ rndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl) + + default: + invalid: +- F_RNDIS_DBG("invalid control req%02x.%02x v%04x i%04x l%d\n", +- ctrl->bRequestType, ctrl->bRequest, +- w_value, w_index, w_length); +- + VDBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n", + ctrl->bRequestType, ctrl->bRequest, + w_value, w_index, w_length); +@@ -630,18 +542,13 @@ static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt) + struct usb_composite_dev *cdev = f->config->cdev; + + /* we know alt == 0 */ +- F_RNDIS_DBG("interface :%d, rndis ctrl id :%d, rndis data id :%d\n" , +- intf, rndis->ctrl_id, rndis->data_id); +- + + if (intf == rndis->ctrl_id) { + if (rndis->notify->driver_data) { +- F_RNDIS_DBG("reset rndis control %d\n", intf); + VDBG(cdev, "reset rndis control %d\n", intf); + 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; +@@ -653,13 +560,11 @@ static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt) + struct net_device *net; + + if (rndis->port.in_ep->driver_data) { +- F_RNDIS_DBG("reset rndis\n"); + DBG(cdev, "reset rndis\n"); + gether_disconnect(&rndis->port); + } + + if (!rndis->port.in_ep->desc || !rndis->port.out_ep->desc) { +- F_RNDIS_DBG("init rndis\n"); + DBG(cdev, "init rndis\n"); + if (config_ep_by_speed(cdev->gadget, f, + rndis->port.in_ep) || +@@ -688,7 +593,7 @@ static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt) + */ + rndis->port.cdc_filter = 0; + +- DBG(cdev, "RNDIS RX/TX early activation ...\n"); ++ DBG(cdev, "RNDIS RX/TX early activation ... \n"); + net = gether_connect(&rndis->port); + if (IS_ERR(net)) + return PTR_ERR(net); +@@ -711,7 +616,6 @@ static void rndis_disable(struct usb_function *f) + if (!rndis->notify->driver_data) + return; + +- F_RNDIS_DBG("\n"); + DBG(cdev, "rndis deactivated\n"); + + rndis_uninit(rndis->config); +@@ -735,7 +639,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->config, RNDIS_MEDIUM_802_3, +@@ -747,7 +650,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->config, RNDIS_MEDIUM_802_3, 0); +@@ -776,8 +678,6 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f) + + struct f_rndis_opts *rndis_opts; + +- F_RNDIS_DBG("\n"); +- + if (!can_support_rndis(c)) + return -EINVAL; + +@@ -799,9 +699,7 @@ 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->bound) { */ +- if (rndis_opts && !rndis_opts->bound) { ++ if (!rndis_opts->bound) { + gether_set_gadget(rndis_opts->net, cdev->gadget); + status = gether_register_netdev(rndis_opts->net); + if (status) +@@ -872,11 +770,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; +@@ -905,7 +799,6 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f) + + rndis_set_param_medium(rndis->config, RNDIS_MEDIUM_802_3, 0); + rndis_set_host_mac(rndis->config, rndis->ethaddr); +- rndis_set_max_pkt_xfer(rndis->config, rndis_ul_max_pkt_per_xfer); + + if (rndis->manufacturer && rndis->vendorID && + rndis_set_param_vendor(rndis->config, rndis->vendorID, +@@ -919,11 +812,6 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f) + * until we're activated via set_alt(). + */ + +- F_RNDIS_DBG("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); + 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", +@@ -955,76 +843,6 @@ fail: + return status; + } + +-static void +-rndis_old_unbind(struct usb_configuration *c, struct usb_function *f) +-{ +- struct f_rndis *rndis = func_to_rndis(f); +- +- F_RNDIS_DBG("\n"); +- +- rndis_deregister(rndis->config); +- +- usb_free_all_descriptors(f); +- +- kfree(rndis->notify_req->buf); +- usb_ep_free_request(rndis->notify, rndis->notify_req); +- +- kfree(rndis); +-} +- +-int +-rndis_bind_config_vendor(struct usb_configuration *c, u8 ethaddr[ETH_ALEN], +- u32 vendorID, const char *manufacturer, struct eth_dev *dev) +-{ +- struct f_rndis *rndis; +- int status; +- +- /* allocate and initialize one new instance */ +- status = -ENOMEM; +- rndis = kzalloc(sizeof(*rndis), GFP_KERNEL); +- if (!rndis) +- goto fail; +- +- ether_addr_copy(rndis->ethaddr, ethaddr); +- rndis->vendorID = vendorID; +- rndis->manufacturer = manufacturer; +- +- rndis->port.ioport = dev; +- /* 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.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 */ +- rndis->port.func.bind = rndis_bind; +- /* note here use rndis_old_unbind */ +- rndis->port.func.unbind = rndis_old_unbind; +- rndis->port.func.set_alt = rndis_set_alt; +- rndis->port.func.setup = rndis_setup; +- rndis->port.func.disable = rndis_disable; +- +- status = rndis_register(rndis_response_available, rndis); +- if (status < 0) { +- kfree(rndis); +- return status; +- } +- rndis->config = status; +- +- status = usb_add_function(c, &rndis->port.func); +- if (status) +- kfree(rndis); +-fail: +- +- F_RNDIS_DBG("done, status %d\n", status); +- return status; +-} +- + void rndis_borrow_net(struct usb_function_instance *f, struct net_device *net) + { + struct f_rndis_opts *opts; +@@ -1139,7 +957,6 @@ static void rndis_unbind(struct usb_configuration *c, struct usb_function *f) + { + struct f_rndis *rndis = func_to_rndis(f); + +- F_RNDIS_DBG("\n"); + kfree(f->os_desc_table); + f->os_desc_n = 0; + usb_free_all_descriptors(f); +@@ -1176,8 +993,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 */ +diff --git a/drivers/usb/gadget/function/rndis.c b/drivers/usb/gadget/function/rndis.c +index 411ba6f934ad..95d2324f6977 100644 +--- a/drivers/usb/gadget/function/rndis.c ++++ b/drivers/usb/gadget/function/rndis.c +@@ -49,7 +49,7 @@ + * and will be happier if you provide the host_addr module parameter. + */ + +-#if 1 ++#if 0 + static int rndis_debug = 0; + module_param (rndis_debug, int, 0); + MODULE_PARM_DESC (rndis_debug, "enable debugging"); +@@ -59,16 +59,6 @@ MODULE_PARM_DESC (rndis_debug, "enable debugging"); + + #define RNDIS_MAX_CONFIGS 1 + +-int rndis_ul_max_pkt_per_xfer_rcvd; +-module_param(rndis_ul_max_pkt_per_xfer_rcvd, int, S_IRUGO); +-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, S_IRUGO); +-MODULE_PARM_DESC(rndis_ul_max_xfer_size_rcvd, +- "Max size of bus transfer received"); +- + + static rndis_params rndis_per_dev_params[RNDIS_MAX_CONFIGS]; + +@@ -168,7 +158,6 @@ static const u32 oid_supported_list[] = + #endif /* RNDIS_PM */ + }; + +-#define RNDIS_DBG(fmt, args...) pr_debug("RNDIS,%s, " fmt, __func__, ## args) + + /* NDIS Functions */ + static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf, +@@ -206,9 +195,6 @@ static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf, + net = rndis_per_dev_params[configNr].dev; + stats = dev_get_stats(net, &temp); + +- if (rndis_debug) +- RNDIS_DBG("OID is 0x%x, configNr is %d\n", OID, configNr); +- + switch (OID) { + + /* general oids (table 4-1) */ +@@ -271,17 +257,6 @@ static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf, + else + *outbuf = cpu_to_le32( + rndis_per_dev_params[configNr].speed); +- if (rndis_debug) +- RNDIS_DBG("OID_GEN_LINK_SPEED, speed %d, data: rx_in %lu\n" +- "rx_out %lu, rx_nomem %lu, rx_error %lu, tx_in %lu\n" +- "tx_out %lu, tx_busy %lu, tx_complete %lu, last_msg_id: 0x%x\n" +- "last_resp_id: 0x%x, RNDIS reset cnt: 0x%lu, queue stopped? %d\n", +- rndis_per_dev_params[configNr].speed, rndis_test_rx_usb_in, +- rndis_test_rx_net_out, rndis_test_rx_nomem, rndis_test_rx_error, +- rndis_test_tx_net_in, rndis_test_tx_usb_out, rndis_test_tx_busy, +- rndis_test_tx_complete, rndis_test_last_msg_id, +- rndis_test_last_resp_id, rndis_test_reset_msg_cnt, +- netif_queue_stopped(rndis_per_dev_params[configNr].dev)); + retval = 0; + break; + +@@ -355,9 +330,6 @@ static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf, + pr_debug("%s: RNDIS_OID_GEN_MEDIA_CONNECT_STATUS\n", __func__); + *outbuf = cpu_to_le32(rndis_per_dev_params[configNr] + .media_state); +- if (rndis_debug) +- RNDIS_DBG("OID_GEN_MEDIA_CONNECT_STATUS, media_state %d\n", +- rndis_per_dev_params[configNr].media_state); + retval = 0; + break; + +@@ -409,8 +381,6 @@ static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf, + pr_debug("%s: RNDIS_OID_GEN_XMIT_ERROR\n", __func__); + if (stats) { + *outbuf = cpu_to_le32(stats->tx_errors); +- if (rndis_debug) +- RNDIS_DBG("OID_GEN_XMIT_ERROR, stats->tx_errors %llu\n", stats->tx_errors); + retval = 0; + } + break; +@@ -421,8 +391,6 @@ static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf, + pr_debug("%s: RNDIS_OID_GEN_RCV_ERROR\n", __func__); + if (stats) { + *outbuf = cpu_to_le32(stats->rx_errors); +- if (rndis_debug) +- RNDIS_DBG("OID_GEN_RCV_ERROR, stats->rx_errors %llu\n", stats->rx_errors); + retval = 0; + } + break; +@@ -432,8 +400,6 @@ static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf, + pr_debug("%s: RNDIS_OID_GEN_RCV_NO_BUFFER\n", __func__); + if (stats) { + *outbuf = cpu_to_le32(stats->rx_dropped); +- if (rndis_debug) +- RNDIS_DBG("OID_GEN_RCV_NO_BUFFER, stats->rx_dropped %llu\n", stats->rx_dropped); + retval = 0; + } + break; +@@ -449,10 +415,6 @@ static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf, + rndis_per_dev_params[configNr].host_mac, + length); + retval = 0; +- if (rndis_debug) +- RNDIS_DBG("OID_802_3_PERMANENT_ADDRESS, host_mac is %x %x ....\n", +- rndis_per_dev_params[configNr].host_mac[0], +- rndis_per_dev_params[configNr].host_mac[1]); + } + break; + +@@ -464,10 +426,6 @@ static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf, + memcpy(outbuf, + rndis_per_dev_params [configNr].host_mac, + length); +- if (rndis_debug) +- RNDIS_DBG("OID_802_3_CURRENT_ADDRESS, host_mac is %x %x ....\n", +- rndis_per_dev_params[configNr].host_mac[0], +- rndis_per_dev_params[configNr].host_mac[1]); + retval = 0; + } + break; +@@ -500,9 +458,6 @@ static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf, + case RNDIS_OID_802_3_RCV_ERROR_ALIGNMENT: + pr_debug("%s: RNDIS_OID_802_3_RCV_ERROR_ALIGNMENT\n", __func__); + if (stats) { +- if (rndis_debug) +- RNDIS_DBG("OID_802_3_RCV_ERROR_ALIGNMENT, stats->rx_frame_errors is %llu\n", +- stats->rx_frame_errors); + *outbuf = cpu_to_le32(stats->rx_frame_errors); + retval = 0; + } +@@ -526,10 +481,8 @@ static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf, + pr_warning("%s: query unknown OID 0x%08X\n", + __func__, OID); + } +- if (retval < 0) { ++ if (retval < 0) + length = 0; +- RNDIS_DBG("bad gen_ndis_query_resp, retval is 0x%d\n", retval); +- } + + resp->InformationBufferLength = cpu_to_le32(length); + r->length = length + sizeof(*resp); +@@ -561,9 +514,6 @@ static int gen_ndis_set_resp(u8 configNr, u32 OID, u8 *buf, u32 buf_len, + } + } + +- if (rndis_debug) +- RNDIS_DBG("OID is 0x%x\n", OID); +- + params = &rndis_per_dev_params[configNr]; + switch (OID) { + case RNDIS_OID_GEN_CURRENT_PACKET_FILTER: +@@ -606,8 +556,6 @@ static int gen_ndis_set_resp(u8 configNr, u32 OID, u8 *buf, u32 buf_len, + __func__, OID, buf_len); + } + +- if (retval) +- RNDIS_DBG("retval is 0x%d\n", retval); + return retval; + } + +@@ -637,12 +585,12 @@ static int rndis_init_response(int configNr, rndis_init_msg_type *buf) + 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); +@@ -669,10 +617,8 @@ static int rndis_query_response(int configNr, rndis_query_msg_type *buf) + */ + r = rndis_add_response(configNr, + 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); +@@ -703,10 +649,8 @@ static int rndis_set_response(int configNr, rndis_set_msg_type *buf) + struct rndis_params *params = rndis_per_dev_params + configNr; + + r = rndis_add_response(configNr, sizeof(rndis_set_cmplt_type)); +- if (!r) { +- RNDIS_DBG("rndis_add_response return NULL\n"); ++ if (!r) + return -ENOMEM; +- } + resp = (rndis_set_cmplt_type *)r->buf; + + BufLength = le32_to_cpu(buf->InformationBufferLength); +@@ -742,15 +686,6 @@ static int rndis_reset_response(int configNr, rndis_reset_msg_type *buf) + rndis_reset_cmplt_type *resp; + rndis_resp_t *r; + struct rndis_params *params = rndis_per_dev_params + configNr; +- u32 length; +- u8 *xbuf; +- +- RNDIS_DBG("reset, clean old response\n"); +- /* drain the response queue */ +- while ((xbuf = rndis_get_next_response(configNr, &length))) +- rndis_free_response(configNr, xbuf); +- +- rndis_test_reset_msg_cnt++; + + r = rndis_add_response(configNr, sizeof(rndis_reset_cmplt_type)); + if (!r) +@@ -777,10 +712,8 @@ static int rndis_keepalive_response(int configNr, + /* host "should" check only in RNDIS_DATA_INITIALIZED state */ + + r = rndis_add_response(configNr, 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); +@@ -789,17 +722,6 @@ static int rndis_keepalive_response(int configNr, + resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS); + + params->resp_avail(params->v); +- +- if (rndis_debug) +- RNDIS_DBG("data: rx_in %lu\n" +- "rx_out %lu, rx_nomem %lu, rx_error %lu, tx_in %lu\n" +- "tx_out %lu, tx_busy %lu, tx_complete %lu, last_msg_id: 0x%x\n" +- "last_resp_id: 0x%x, RNDIS reset cnt: 0x%lu, queue stopped? %d\n", +- rndis_test_rx_usb_in, rndis_test_rx_net_out, rndis_test_rx_nomem, rndis_test_rx_error, +- rndis_test_tx_net_in, rndis_test_tx_usb_out, rndis_test_tx_busy, +- rndis_test_tx_complete, rndis_test_last_msg_id, +- rndis_test_last_resp_id, +- rndis_test_reset_msg_cnt, netif_queue_stopped(params->dev)); + return 0; + } + +@@ -876,7 +798,7 @@ EXPORT_SYMBOL_GPL(rndis_set_host_mac); + */ + int rndis_msg_parser(u8 configNr, u8 *buf) + { +- u32 MsgType, MsgLength, MsgID; ++ u32 MsgType, MsgLength; + __le32 *tmp; + struct rndis_params *params; + +@@ -886,10 +808,6 @@ int rndis_msg_parser(u8 configNr, 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,configNr is %d, RequestID is 0x%x\n", MsgType, configNr, MsgID); +- rndis_test_last_msg_id = MsgID; + + if (configNr >= RNDIS_MAX_CONFIGS) + return -ENOTSUPP; +@@ -949,27 +867,8 @@ int rndis_msg_parser(u8 configNr, u8 *buf) + */ + pr_warning("%s: unknown RNDIS message 0x%08X len %d\n", + __func__, MsgType, MsgLength); +- { +- unsigned 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); */ ++ print_hex_dump_bytes(__func__, DUMP_PREFIX_OFFSET, ++ buf, MsgLength); + break; + } + +@@ -989,7 +888,6 @@ int rndis_register(void (*resp_avail)(void *v), void *v) + rndis_per_dev_params[i].used = 1; + rndis_per_dev_params[i].resp_avail = resp_avail; + rndis_per_dev_params[i].v = v; +- rndis_per_dev_params[i].max_pkt_per_xfer = 1; + pr_debug("%s: configNr = %d\n", __func__, i); + return i; + } +@@ -1019,8 +917,6 @@ int rndis_set_param_dev(u8 configNr, struct net_device *dev, u16 *cdc_filter) + rndis_per_dev_params[configNr].dev = dev; + rndis_per_dev_params[configNr].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); +@@ -1050,13 +946,6 @@ int rndis_set_param_medium(u8 configNr, u32 medium, u32 speed) + } + EXPORT_SYMBOL_GPL(rndis_set_param_medium); + +-void rndis_set_max_pkt_xfer(u8 configNr, u8 max_pkt_per_xfer) +-{ +- pr_debug("%s:\n", __func__); +- +- rndis_per_dev_params[configNr].max_pkt_per_xfer = max_pkt_per_xfer; +-} +- + void rndis_add_hdr(struct sk_buff *skb) + { + struct rndis_packet_msg_type *header; +@@ -1080,9 +969,6 @@ void rndis_free_response(int configNr, u8 *buf) + list_for_each_safe(act, tmp, + &(rndis_per_dev_params[configNr].resp_queue)) + { +- if (!act) +- continue; +- + r = list_entry(act, rndis_resp_t, list); + if (r && r->buf == buf) { + list_del(&r->list); +@@ -1135,73 +1021,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; +- +- /* some rndis hosts send extra byte to avoid zlp, ignore it */ +- if (skb->len == 1) { +- dev_kfree_skb_any(skb); +- return 0; +- } +- +- if (skb->len < sizeof *hdr) { +- pr_err("invalid rndis pkt: skblen:%u hdr_len:%u", +- (unsigned int)(skb->len), (unsigned int)sizeof(*hdr)); +- dev_kfree_skb_any(skb); +- return -EINVAL; +- } +- +- 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_err("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 -EOVERFLOW; +- } +- if (le32_to_cpu(hdr->MessageType) != RNDIS_MSG_PACKET) { +- pr_err("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; +- } ++ /* tmp points to a struct rndis_packet_msg_type */ ++ __le32 *tmp = (void *)skb->data; + +- 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_err("%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++; ++ /* MessageType, MessageLength */ ++ if (cpu_to_le32(RNDIS_MSG_PACKET) ++ != get_unaligned(tmp++)) { ++ dev_kfree_skb_any(skb); ++ return -EINVAL; + } ++ tmp++; + +- if (num_pkts > rndis_ul_max_pkt_per_xfer_rcvd) +- rndis_ul_max_pkt_per_xfer_rcvd = num_pkts; ++ /* DataOffset, DataLength */ ++ if (!skb_pull(skb, get_unaligned_le32(tmp++) + 8)) { ++ dev_kfree_skb_any(skb); ++ return -EOVERFLOW; ++ } ++ skb_trim(skb, get_unaligned_le32(tmp++)); + + skb_queue_tail(list, skb); + return 0; +@@ -1222,9 +1058,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) { +@@ -1238,13 +1072,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; + } + +@@ -1307,12 +1135,13 @@ 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 */ + ++ + int rndis_init(void) + { + u8 i; +diff --git a/drivers/usb/gadget/function/rndis.h b/drivers/usb/gadget/function/rndis.h +index 145f01b18190..0f4abb4c3775 100644 +--- a/drivers/usb/gadget/function/rndis.h ++++ b/drivers/usb/gadget/function/rndis.h +@@ -190,7 +190,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; +@@ -206,7 +205,6 @@ int rndis_set_param_dev (u8 configNr, struct net_device *dev, + int rndis_set_param_vendor (u8 configNr, u32 vendorID, + const char *vendorDescr); + int rndis_set_param_medium (u8 configNr, u32 medium, u32 speed); +-void rndis_set_max_pkt_xfer(u8 configNr, 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); +diff --git a/drivers/usb/gadget/function/u_ether.c b/drivers/usb/gadget/function/u_ether.c +index 05cef7e1b718..33011f8ee865 100644 +--- a/drivers/usb/gadget/function/u_ether.c ++++ b/drivers/usb/gadget/function/u_ether.c +@@ -23,8 +23,7 @@ + #include + + #include "u_ether.h" +-#include "usb_boost.h" +-#include "rndis.h" ++ + + /* + * This component encapsulates the Ethernet link glue needed to provide +@@ -49,9 +48,6 @@ + + #define UETH__VERSION "29-May-2008" + +-static struct workqueue_struct *uether_wq; +-static struct workqueue_struct *uether_wq1; +- + struct eth_dev { + /* lock is held while accessing port_usb + */ +@@ -61,32 +57,21 @@ struct eth_dev { + struct net_device *net; + struct usb_gadget *gadget; + +- spinlock_t req_lock; /* guard {tx}_reqs */ +- spinlock_t reqrx_lock; /* guard {rx}_reqs */ ++ spinlock_t req_lock; /* guard {rx,tx}_reqs */ + struct list_head tx_reqs, rx_reqs; +- unsigned tx_qlen; +-/* Minimum number of TX USB request queued to UDC */ +-#define TX_REQ_THRESHOLD 5 +- int no_tx_req_used; +- int tx_skb_hold_count; +- u32 tx_req_bufsize; ++ atomic_t tx_qlen; + + struct sk_buff_head rx_frames; + + unsigned qmult; + + unsigned header_len; +- unsigned ul_max_pkts_per_xfer; +- unsigned dl_max_pkts_per_xfer; +- uint32_t dl_max_xfer_size; + struct sk_buff *(*wrap)(struct gether *, struct sk_buff *skb); + int (*unwrap)(struct gether *, + struct sk_buff *skb, + struct sk_buff_head *list); + + struct work_struct work; +- struct work_struct rx_work; +- struct work_struct rx_work1; + + unsigned long todo; + #define WORK_RX_MEMORY 0 +@@ -102,14 +87,6 @@ struct eth_dev { + + #define DEFAULT_QLEN 2 /* double buffering by default */ + +-static unsigned tx_wakeup_threshold = 13; +-module_param(tx_wakeup_threshold, uint, S_IRUGO|S_IWUSR); +-MODULE_PARM_DESC(tx_wakeup_threshold, "tx wakeup threshold value"); +- +-#define U_ETHER_RX_PENDING_TSHOLD 100 +-static unsigned int u_ether_rx_pending_thld = U_ETHER_RX_PENDING_TSHOLD; +-module_param(u_ether_rx_pending_thld, uint, S_IRUGO | S_IWUSR); +- + /* for dual-speed hardware, use deeper queues at high/super speed */ + static inline int qlen(struct usb_gadget *gadget, unsigned qmult) + { +@@ -156,23 +133,6 @@ static inline int qlen(struct usb_gadget *gadget, unsigned qmult) + xprintk(dev , KERN_INFO , fmt , ## args) + + /*-------------------------------------------------------------------------*/ +-unsigned int rndis_test_last_resp_id; +-unsigned int rndis_test_last_msg_id; +- +-unsigned long rndis_test_reset_msg_cnt; +- +-unsigned long rndis_test_rx_usb_in; +-unsigned long rndis_test_rx_net_out; +-unsigned long rndis_test_rx_nomem; +-unsigned long rndis_test_rx_error; +- +-unsigned long rndis_test_tx_net_in; +-unsigned long rndis_test_tx_busy; +-unsigned long rndis_test_tx_stop; +- +-unsigned long rndis_test_tx_usb_out; +-unsigned long rndis_test_tx_complete; +-#define U_ETHER_DBG(fmt, args...) pr_debug("U_ETHER,%s, " fmt, __func__, ## args) + + /* NETWORK DRIVER HOOKUP (to the layer above this driver) */ + +@@ -191,7 +151,6 @@ static int ueth_change_mtu(struct net_device *net, int new_mtu) + else + net->mtu = new_mtu; + spin_unlock_irqrestore(&dev->lock, flags); +- U_ETHER_DBG("mtu to %d, status is %d\n", new_mtu , status); + + return status; + } +@@ -228,7 +187,6 @@ static void defer_kevent(struct eth_dev *dev, int flag) + } + + static void rx_complete(struct usb_ep *ep, struct usb_request *req); +-static void tx_complete(struct usb_ep *ep, struct usb_request *req); + + static int + rx_submit(struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags) +@@ -267,18 +225,12 @@ rx_submit(struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags) + size += out->maxpacket - 1; + size -= size % out->maxpacket; + +- if (dev->ul_max_pkts_per_xfer) +- size *= dev->ul_max_pkts_per_xfer; +- + if (dev->port_usb->is_fixed) + size = max_t(size_t, size, dev->port_usb->fixed_out_len); + +- U_ETHER_DBG("size:%d, mtu:%d, hdr_len:%d, maxpacket:%d, ul_max_pkts_per_xfer:%d", +- (int)size, dev->net->mtu, dev->port_usb->header_len, out->maxpacket, dev->ul_max_pkts_per_xfer); + skb = alloc_skb(size + NET_IP_ALIGN, gfp_flags); + if (skb == NULL) { +- U_ETHER_DBG("no rx skb\n"); +- rndis_test_rx_nomem++; ++ DBG(dev, "no rx skb\n"); + goto enomem; + } + +@@ -290,6 +242,7 @@ rx_submit(struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags) + + req->buf = skb->data; + req->length = size; ++ req->complete = rx_complete; + req->context = skb; + + retval = usb_ep_queue(out, req, gfp_flags); +@@ -300,22 +253,23 @@ enomem: + DBG(dev, "rx submit --> %d\n", retval); + if (skb) + dev_kfree_skb_any(skb); ++ spin_lock_irqsave(&dev->req_lock, flags); ++ list_add(&req->list, &dev->rx_reqs); ++ spin_unlock_irqrestore(&dev->req_lock, flags); + } + return retval; + } + + static void rx_complete(struct usb_ep *ep, struct usb_request *req) + { +- struct sk_buff *skb = req->context; ++ struct sk_buff *skb = req->context, *skb2; + struct eth_dev *dev = ep->driver_data; + int status = req->status; +- bool queue = 0; + + switch (status) { + + /* normal completion */ + case 0: +- U_ETHER_DBG("len(%d)\n", req->actual); + skb_put(skb, req->actual); + + if (dev->unwrap) { +@@ -326,10 +280,6 @@ static void rx_complete(struct usb_ep *ep, struct usb_request *req) + status = dev->unwrap(dev->port_usb, + skb, + &dev->rx_frames); +- if (status == -EINVAL) +- dev->net->stats.rx_errors++; +- else if (status == -EOVERFLOW) +- dev->net->stats.rx_over_errors++; + } else { + dev_kfree_skb_any(skb); + status = -ENOTCONN; +@@ -338,10 +288,30 @@ static void rx_complete(struct usb_ep *ep, struct usb_request *req) + } else { + skb_queue_tail(&dev->rx_frames, skb); + } ++ skb = NULL; ++ ++ skb2 = skb_dequeue(&dev->rx_frames); ++ while (skb2) { ++ if (status < 0 ++ || ETH_HLEN > skb2->len ++ || skb2->len > VLAN_ETH_FRAME_LEN) { ++ dev->net->stats.rx_errors++; ++ dev->net->stats.rx_length_errors++; ++ DBG(dev, "rx length %d\n", skb2->len); ++ dev_kfree_skb_any(skb2); ++ goto next_frame; ++ } ++ skb2->protocol = eth_type_trans(skb2, dev->net); ++ dev->net->stats.rx_packets++; ++ dev->net->stats.rx_bytes += skb2->len; + +- if (!status) +- queue = 1; +- rndis_test_rx_usb_in++; ++ /* no buffer copies needed, unless hardware can't ++ * use skb buffers. ++ */ ++ status = netif_rx(skb2); ++next_frame: ++ skb2 = skb_dequeue(&dev->rx_frames); ++ } + break; + + /* software-driven interface shutdown */ +@@ -364,37 +334,28 @@ quiesce: + /* FALLTHROUGH */ + + default: +- queue = 1; +- dev_kfree_skb_any(skb); + dev->net->stats.rx_errors++; + DBG(dev, "rx status %d\n", status); + break; + } + ++ if (skb) ++ dev_kfree_skb_any(skb); ++ if (!netif_running(dev->net)) { + clean: +- if (queue && dev->rx_frames.qlen <= u_ether_rx_pending_thld) { +- if (rx_submit(dev, req, GFP_ATOMIC) < 0) { +- spin_lock(&dev->reqrx_lock); +- list_add(&req->list, &dev->rx_reqs); +- spin_unlock(&dev->reqrx_lock); +- } +- } else { +- spin_lock(&dev->reqrx_lock); ++ spin_lock(&dev->req_lock); + list_add(&req->list, &dev->rx_reqs); +- spin_unlock(&dev->reqrx_lock); +- } +- +- if (queue) { +- queue_work(uether_wq, &dev->rx_work); +- queue_work(uether_wq1, &dev->rx_work1); ++ spin_unlock(&dev->req_lock); ++ req = NULL; + } ++ if (req) ++ rx_submit(dev, req, GFP_ATOMIC); + } + + static int prealloc(struct list_head *list, struct usb_ep *ep, unsigned n) + { + unsigned i; + struct usb_request *req; +- bool usb_in; + + if (!n) + return -ENOMEM; +@@ -405,21 +366,10 @@ static int prealloc(struct list_head *list, struct usb_ep *ep, unsigned n) + if (i-- == 0) + goto extra; + } +- +- if (ep->desc->bEndpointAddress & USB_DIR_IN) +- usb_in = true; +- else +- usb_in = false; +- + while (i--) { + req = usb_ep_alloc_request(ep, GFP_ATOMIC); + if (!req) + return list_empty(list) ? -ENOMEM : 0; +- /* update completion handler */ +- if (usb_in) +- req->complete = tx_complete; +- else +- req->complete = rx_complete; + list_add(&req->list, list); + } + return 0; +@@ -447,22 +397,16 @@ static int alloc_requests(struct eth_dev *dev, struct gether *link, unsigned n) + + spin_lock(&dev->req_lock); + status = prealloc(&dev->tx_reqs, link->in_ep, n); +- if (status < 0) { +- spin_unlock(&dev->req_lock); +- U_ETHER_DBG("can't alloc tx requests\n"); +- return status; +- } +- spin_unlock(&dev->req_lock); +- +- spin_lock(&dev->reqrx_lock); ++ if (status < 0) ++ goto fail; + status = prealloc(&dev->rx_reqs, link->out_ep, n); +- if (status < 0) { +- spin_unlock(&dev->reqrx_lock); +- U_ETHER_DBG("can't alloc rx requests\n"); +- return status; +- } +- spin_unlock(&dev->reqrx_lock); +- ++ if (status < 0) ++ goto fail; ++ goto done; ++fail: ++ DBG(dev, "can't alloc requests\n"); ++done: ++ spin_unlock(&dev->req_lock); + return status; + } + +@@ -470,69 +414,23 @@ static void rx_fill(struct eth_dev *dev, gfp_t gfp_flags) + { + struct usb_request *req; + unsigned long flags; +- int req_cnt = 0; + + /* fill unused rxq slots with some skb */ +- spin_lock_irqsave(&dev->reqrx_lock, flags); ++ spin_lock_irqsave(&dev->req_lock, flags); + while (!list_empty(&dev->rx_reqs)) { +- /* break the nexus of continuous completion and re-submission*/ +- if (++req_cnt > qlen(dev->gadget, dev->qmult)) +- break; +- + req = container_of(dev->rx_reqs.next, + struct usb_request, list); + list_del_init(&req->list); +- spin_unlock_irqrestore(&dev->reqrx_lock, flags); ++ spin_unlock_irqrestore(&dev->req_lock, flags); + + if (rx_submit(dev, req, gfp_flags) < 0) { +- spin_lock_irqsave(&dev->reqrx_lock, flags); +- list_add(&req->list, &dev->rx_reqs); +- spin_unlock_irqrestore(&dev->reqrx_lock, flags); + defer_kevent(dev, WORK_RX_MEMORY); + return; + } + +- spin_lock_irqsave(&dev->reqrx_lock, flags); +- } +- spin_unlock_irqrestore(&dev->reqrx_lock, flags); +-} +- +-static void process_rx_w(struct work_struct *work) +-{ +- struct eth_dev *dev = container_of(work, struct eth_dev, rx_work); +- struct sk_buff *skb; +- int status = 0; +- +- if (!dev->port_usb) +- return; +- +- while ((skb = skb_dequeue(&dev->rx_frames))) { +- if (status < 0 +- || ETH_HLEN > skb->len +- || skb->len > ETH_FRAME_LEN) { +- dev->net->stats.rx_errors++; +- dev->net->stats.rx_length_errors++; +- rndis_test_rx_error++; +- DBG(dev, "rx length %d\n", skb->len); +- dev_kfree_skb_any(skb); +- continue; +- } +- skb->protocol = eth_type_trans(skb, dev->net); +- dev->net->stats.rx_packets++; +- dev->net->stats.rx_bytes += skb->len; +-#if defined(NETDEV_TRACE) && defined(NETDEV_UL_TRACE) +- skb->dbg_flag = 0x4; +-#endif +- +- rndis_test_rx_net_out++; +- status = netif_rx_ni(skb); ++ spin_lock_irqsave(&dev->req_lock, flags); + } +- +-/* move to another workthread */ +-#if 0 +- if (netif_running(dev->net)) +- rx_fill(dev, GFP_KERNEL); +-#endif ++ spin_unlock_irqrestore(&dev->req_lock, flags); + } + + static void eth_work(struct work_struct *work) +@@ -548,39 +446,10 @@ static void eth_work(struct work_struct *work) + DBG(dev, "work done, flags = 0x%lx\n", dev->todo); + } + +-static void process_rx_w1(struct work_struct *work) +-{ +- struct eth_dev *dev = container_of(work, struct eth_dev, rx_work1); +- +- if (!dev->port_usb) +- return; +- +- if (netif_running(dev->net)) +- rx_fill(dev, GFP_KERNEL); +-} +- + static void tx_complete(struct usb_ep *ep, struct usb_request *req) + { +- struct sk_buff *skb; +- struct eth_dev *dev; +- struct net_device *net; +- struct usb_request *new_req; +- struct usb_ep *in; +- int length; +- int retval; +- +- if (!ep->driver_data) { +- usb_ep_free_request(ep, req); +- return; +- } +- +- dev = ep->driver_data; +- net = dev->net; +- +- if (!dev->port_usb) { +- usb_ep_free_request(ep, req); +- return; +- } ++ struct sk_buff *skb = req->context; ++ struct eth_dev *dev = ep->driver_data; + + switch (req->status) { + default: +@@ -591,104 +460,18 @@ static void tx_complete(struct usb_ep *ep, struct usb_request *req) + case -ESHUTDOWN: /* disconnect etc */ + break; + case 0: +- if (!req->zero) +- dev->net->stats.tx_bytes += req->length-1; +- else +- dev->net->stats.tx_bytes += req->length; ++ dev->net->stats.tx_bytes += skb->len; + } + dev->net->stats.tx_packets++; +- rndis_test_tx_complete++; + + spin_lock(&dev->req_lock); +- list_add_tail(&req->list, &dev->tx_reqs); +- +- if (dev->port_usb->multi_pkt_xfer && !req->context) { +- dev->no_tx_req_used--; +- req->length = 0; +- in = dev->port_usb->in_ep; +- +- if (!list_empty(&dev->tx_reqs)) { +- new_req = container_of(dev->tx_reqs.next, +- struct usb_request, list); +- list_del(&new_req->list); +- spin_unlock(&dev->req_lock); +- if (new_req->length > 0) { +- length = new_req->length; +- +- /* NCM requires no zlp if transfer is +- * dwNtbInMaxSize */ +- if (dev->port_usb->is_fixed && +- length == dev->port_usb->fixed_in_len && +- (length % in->maxpacket) == 0) +- new_req->zero = 0; +- else +- new_req->zero = 1; +- +- /* use zlp framing on tx for strict CDC-Ether +- * conformance, though any robust network rx +- * path ignores extra padding. and some hardware +- * doesn't like to write zlps. +- */ +- if (new_req->zero && !dev->zlp && +- (length % in->maxpacket) == 0) { +- new_req->zero = 0; +- length++; +- } +- +- new_req->length = length; +- retval = usb_ep_queue(in, new_req, GFP_ATOMIC); +- switch (retval) { +- default: +- DBG(dev, "tx queue err %d\n", retval); +- new_req->length = 0; +- spin_lock(&dev->req_lock); +- list_add_tail(&new_req->list, &dev->tx_reqs); +- spin_unlock(&dev->req_lock); +- break; +- case 0: +- spin_lock(&dev->req_lock); +- dev->no_tx_req_used++; +- spin_unlock(&dev->req_lock); +- net->trans_start = jiffies; +- } +- } else { +- spin_lock(&dev->req_lock); +- /* +- * Put the idle request at the back of the +- * queue. The xmit function will put the +- * unfinished request at the beginning of the +- * queue. +- */ +- list_add_tail(&new_req->list, &dev->tx_reqs); +- spin_unlock(&dev->req_lock); +- } +- } else { +- spin_unlock(&dev->req_lock); +- } +- } else { +- skb = req->context; +- /* Is aggregation already enabled and buffers allocated ? */ +- if (dev->port_usb->multi_pkt_xfer && dev->tx_req_bufsize) { +-#if defined(CONFIG_64BIT) && defined(CONFIG_MTK_LM_MODE) +- req->buf = kzalloc(dev->tx_req_bufsize, GFP_ATOMIC | GFP_DMA); +-#else +- req->buf = kzalloc(dev->tx_req_bufsize, GFP_ATOMIC); +-#endif +- req->context = NULL; +- } else { +- req->buf = NULL; +- } +- +- spin_unlock(&dev->req_lock); +- dev_kfree_skb_any(skb); +- } ++ list_add(&req->list, &dev->tx_reqs); ++ spin_unlock(&dev->req_lock); ++ dev_kfree_skb_any(skb); + +- if (netif_carrier_ok(dev->net)) { +- spin_lock(&dev->req_lock); +- if (dev->no_tx_req_used < tx_wakeup_threshold) +- netif_wake_queue(dev->net); +- spin_unlock(&dev->req_lock); +- } ++ atomic_dec(&dev->tx_qlen); ++ if (netif_carrier_ok(dev->net)) ++ netif_wake_queue(dev->net); + } + + static inline int is_promisc(u16 cdc_filter) +@@ -696,47 +479,6 @@ static inline int is_promisc(u16 cdc_filter) + return cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS; + } + +-static int alloc_tx_buffer(struct eth_dev *dev) +-{ +- struct list_head *act; +- struct usb_request *req; +- +- dev->tx_req_bufsize = (dev->dl_max_pkts_per_xfer * +- (dev->net->mtu +- + sizeof(struct ethhdr) +- /* size of rndis_packet_msg_type */ +- + 44 +- + 22)); +- +- list_for_each(act, &dev->tx_reqs) { +- req = container_of(act, struct usb_request, list); +- if (!req->buf) { +-#if defined(CONFIG_64BIT) && defined(CONFIG_MTK_LM_MODE) +- req->buf = kzalloc(dev->tx_req_bufsize, +- GFP_ATOMIC | GFP_DMA); +-#else +- req->buf = kzalloc(dev->tx_req_bufsize, +- GFP_ATOMIC); +-#endif +- if (!req->buf) +- goto free_buf; +- } +- /* req->context is not used for multi_pkt_xfers */ +- req->context = NULL; +- } +- return 0; +- +-free_buf: +- /* tx_req_bufsize = 0 retries mem alloc on next eth_start_xmit */ +- dev->tx_req_bufsize = 0; +- list_for_each(act, &dev->tx_reqs) { +- req = container_of(act, struct usb_request, list); +- kfree(req->buf); +- req->buf = NULL; +- } +- return -ENOMEM; +-} +- + static netdev_tx_t eth_start_xmit(struct sk_buff *skb, + struct net_device *net) + { +@@ -745,20 +487,16 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb, + int retval; + struct usb_request *req = NULL; + unsigned long flags; +- struct usb_ep *in = NULL; +- u16 cdc_filter = 0; +- bool multi_pkt_xfer = false; +- uint32_t max_size = 0; +- static unsigned int okCnt, busyCnt; +- static DEFINE_RATELIMIT_STATE(ratelimit1, 1 * HZ, 2); +- static DEFINE_RATELIMIT_STATE(ratelimit2, 1 * HZ, 2); ++ struct usb_ep *in; ++ u16 cdc_filter; + + spin_lock_irqsave(&dev->lock, flags); + if (dev->port_usb) { + in = dev->port_usb->in_ep; + cdc_filter = dev->port_usb->cdc_filter; +- multi_pkt_xfer = dev->port_usb->multi_pkt_xfer; +- max_size = dev->dl_max_xfer_size; ++ } else { ++ in = NULL; ++ cdc_filter = 0; + } + spin_unlock_irqrestore(&dev->lock, flags); + +@@ -767,7 +505,6 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb, + return NETDEV_TX_OK; + } + +- + /* apply outgoing CDC or RNDIS filters */ + if (skb && !is_promisc(cdc_filter)) { + u8 *dest = skb->data; +@@ -784,122 +521,57 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb, + type = USB_CDC_PACKET_TYPE_ALL_MULTICAST; + if (!(cdc_filter & type)) { + dev_kfree_skb_any(skb); +- U_ETHER_DBG("cdc_filter error, cdc_filter is 0x%x , type is 0x%x\n", +- cdc_filter , type); + return NETDEV_TX_OK; + } + } + /* ignores USB_CDC_PACKET_TYPE_DIRECTED */ + } +- /* +- * No buffer copies needed, unless the network stack did it +- * or the hardware can't use skb buffers or there's not enough +- * enough space for extra headers we need. +- */ +- spin_lock_irqsave(&dev->lock, flags); +- if (dev->wrap && dev->port_usb) +- skb = dev->wrap(dev->port_usb, skb); +- spin_unlock_irqrestore(&dev->lock, flags); +- +- if (!skb) { +- if (!dev->port_usb->supports_multi_frame) +- dev->net->stats.tx_dropped++; +- /* no error code for dropped packets */ +- return NETDEV_TX_OK; +- } + + spin_lock_irqsave(&dev->req_lock, flags); +- /* Allocate memory for tx_reqs to support multi packet transfer */ +- if (multi_pkt_xfer && !dev->tx_req_bufsize) { +- retval = alloc_tx_buffer(dev); +- if (retval < 0) { +- spin_unlock_irqrestore(&dev->req_lock, flags); +- return -ENOMEM; +- } +- } +- if (__ratelimit(&ratelimit1)) { +- usb_boost(); +- U_ETHER_DBG("spd %d,ms %d,rin %lu,rout %lu,rxmem %lu,rxerr %lu\n" +- "tin %lu,tout %lu,tb %lu,ts %lu,tx_com %lu,lmsg: 0x%x,lrsp:0x%x,rst:%lu\n", +- dev->gadget->speed, max_size, rndis_test_rx_usb_in, rndis_test_rx_net_out, +- rndis_test_rx_nomem, rndis_test_rx_error, rndis_test_tx_net_in, +- rndis_test_tx_usb_out, rndis_test_tx_busy, rndis_test_tx_stop, +- rndis_test_tx_complete, rndis_test_last_msg_id, rndis_test_last_resp_id, +- rndis_test_reset_msg_cnt); +- } +- rndis_test_tx_net_in++; + /* + * this freelist can be empty if an interrupt triggered disconnect() + * and reconfigured the gadget (shutting down this queue) after the + * network stack decided to xmit but before we got the spinlock. + */ + if (list_empty(&dev->tx_reqs)) { +- busyCnt++; +- if (__ratelimit(&ratelimit2)) +- U_ETHER_DBG("okCnt : %u, busyCnt : %u\n", +- okCnt, busyCnt); + spin_unlock_irqrestore(&dev->req_lock, flags); +- rndis_test_tx_busy++; + return NETDEV_TX_BUSY; + } +- okCnt++; + + req = container_of(dev->tx_reqs.next, struct usb_request, list); + list_del(&req->list); + + /* temporarily stop TX queue when the freelist empties */ +- if (list_empty(&dev->tx_reqs)) { +- rndis_test_tx_stop++; ++ if (list_empty(&dev->tx_reqs)) + netif_stop_queue(net); +- } + spin_unlock_irqrestore(&dev->req_lock, flags); + +- if (dev->port_usb == NULL) { +- dev_kfree_skb_any(skb); +- U_ETHER_DBG("port_usb NULL\n"); +- return NETDEV_TX_OK; +- } +- +- if (multi_pkt_xfer) { +- pr_debug("req->length:%d header_len:%u\n" +- "skb->len:%d skb->data_len:%d\n", +- req->length, dev->header_len, +- skb->len, skb->data_len); +- /* Add RNDIS Header */ +- memcpy(req->buf + req->length, dev->port_usb->header, +- dev->header_len); +- /* Increment req length by header size */ +- req->length += dev->header_len; +- /* Copy received IP data from SKB */ +- memcpy(req->buf + req->length, skb->data, skb->len); +- /* Increment req length by skb data length */ +- req->length += skb->len; +- length = req->length; +- dev_kfree_skb_any(skb); +- +- spin_lock_irqsave(&dev->req_lock, flags); +- dev->tx_skb_hold_count++; +- /* if (dev->tx_skb_hold_count < dev->dl_max_pkts_per_xfer) { */ +- if ((dev->tx_skb_hold_count < dev->dl_max_pkts_per_xfer) +- && (length < (max_size - dev->net->mtu))) { +- +- if (dev->no_tx_req_used > TX_REQ_THRESHOLD) { +- list_add(&req->list, &dev->tx_reqs); +- spin_unlock_irqrestore(&dev->req_lock, flags); +- goto success; +- } ++ /* no buffer copies needed, unless the network stack did it ++ * or the hardware can't use skb buffers. ++ * or there's not enough space for extra headers we need ++ */ ++ if (dev->wrap) { ++ unsigned long flags; ++ ++ spin_lock_irqsave(&dev->lock, flags); ++ if (dev->port_usb) ++ skb = dev->wrap(dev->port_usb, skb); ++ spin_unlock_irqrestore(&dev->lock, flags); ++ if (!skb) { ++ /* Multi frame CDC protocols may store the frame for ++ * later which is not a dropped frame. ++ */ ++ if (dev->port_usb->supports_multi_frame) ++ goto multiframe; ++ goto drop; + } +- +- dev->no_tx_req_used++; +- dev->tx_skb_hold_count = 0; +- spin_unlock_irqrestore(&dev->req_lock, flags); +- +- } else { +- length = skb->len; +- req->buf = skb->data; +- req->context = skb; + } + ++ length = skb->len; ++ req->buf = skb->data; ++ req->context = skb; ++ req->complete = tx_complete; ++ + /* NCM requires no zlp if transfer is dwNtbInMaxSize */ + if (dev->port_usb->is_fixed && + length == dev->port_usb->fixed_in_len && +@@ -912,36 +584,32 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb, + * though any robust network rx path ignores extra padding. + * and some hardware doesn't like to write zlps. + */ +- if (req->zero && !dev->zlp && (length % in->maxpacket) == 0) { +- req->zero = 0; ++ if (req->zero && !dev->zlp && (length % in->maxpacket) == 0) + length++; +- } + + req->length = length; + + retval = usb_ep_queue(in, req, GFP_ATOMIC); + switch (retval) { + default: +- U_ETHER_DBG("tx queue err %d\n", retval); ++ DBG(dev, "tx queue err %d\n", retval); + break; + case 0: +- rndis_test_tx_usb_out++; + net->trans_start = jiffies; ++ atomic_inc(&dev->tx_qlen); + } + + if (retval) { +- if (!multi_pkt_xfer) +- dev_kfree_skb_any(skb); +- else +- req->length = 0; ++ dev_kfree_skb_any(skb); ++drop: + dev->net->stats.tx_dropped++; ++multiframe: + spin_lock_irqsave(&dev->req_lock, flags); + if (list_empty(&dev->tx_reqs)) + netif_start_queue(net); +- list_add_tail(&req->list, &dev->tx_reqs); ++ list_add(&req->list, &dev->tx_reqs); + spin_unlock_irqrestore(&dev->req_lock, flags); + } +-success: + return NETDEV_TX_OK; + } + +@@ -949,13 +617,13 @@ success: + + static void eth_start(struct eth_dev *dev, gfp_t gfp_flags) + { +- U_ETHER_DBG("\n"); ++ DBG(dev, "%s\n", __func__); + + /* fill the rx queue */ + rx_fill(dev, gfp_flags); + + /* and open the tx floodgates */ +- dev->tx_qlen = 0; ++ atomic_set(&dev->tx_qlen, 0); + netif_wake_queue(dev->net); + } + +@@ -964,7 +632,7 @@ static int eth_open(struct net_device *net) + struct eth_dev *dev = netdev_priv(net); + struct gether *link; + +- U_ETHER_DBG("\n"); ++ DBG(dev, "%s\n", __func__); + if (netif_carrier_ok(dev->net)) + eth_start(dev, GFP_KERNEL); + +@@ -982,7 +650,7 @@ static int eth_stop(struct net_device *net) + struct eth_dev *dev = netdev_priv(net); + unsigned long flags; + +- U_ETHER_DBG("\n"); ++ VDBG(dev, "%s\n", __func__); + netif_stop_queue(net); + + DBG(dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld\n", +@@ -1028,7 +696,6 @@ static int eth_stop(struct net_device *net) + + /*-------------------------------------------------------------------------*/ + +- + static int get_ether_addr(const char *str, u8 *dev_addr) + { + if (str) { +@@ -1060,20 +727,6 @@ static int get_ether_addr_str(u8 dev_addr[ETH_ALEN], char *str, int len) + dev_addr[3], dev_addr[4], dev_addr[5]); + return 18; + } +-/* defined but not used due to MAC customization */ +-#if 0 +-static u8 host_ethaddr[ETH_ALEN]; +-static int get_host_ether_addr(u8 *str, u8 *dev_addr) +-{ +- memcpy(dev_addr, str, ETH_ALEN); +- if (is_valid_ether_addr(dev_addr)) +- return 0; +- +- random_ether_addr(dev_addr); +- memcpy(str, dev_addr, ETH_ALEN); +- return 1; +-} +-#endif + + static const struct net_device_ops eth_netdev_ops = { + .ndo_open = eth_open, +@@ -1117,10 +770,7 @@ struct eth_dev *gether_setup_name(struct usb_gadget *g, + dev = netdev_priv(net); + spin_lock_init(&dev->lock); + spin_lock_init(&dev->req_lock); +- spin_lock_init(&dev->reqrx_lock); + INIT_WORK(&dev->work, eth_work); +- INIT_WORK(&dev->rx_work, process_rx_w); +- INIT_WORK(&dev->rx_work1, process_rx_w1); + INIT_LIST_HEAD(&dev->tx_reqs); + INIT_LIST_HEAD(&dev->rx_reqs); + +@@ -1134,7 +784,6 @@ struct eth_dev *gether_setup_name(struct usb_gadget *g, + if (get_ether_addr(dev_addr, net->dev_addr)) + dev_warn(&g->dev, + "using random %s ethernet address\n", "self"); +- + if (get_ether_addr(host_addr, dev->host_mac)) + dev_warn(&g->dev, + "using random %s ethernet address\n", "host"); +@@ -1184,8 +833,6 @@ struct net_device *gether_setup_name_default(const char *netname) + spin_lock_init(&dev->lock); + spin_lock_init(&dev->req_lock); + INIT_WORK(&dev->work, eth_work); +- INIT_WORK(&dev->rx_work, process_rx_w); +- INIT_WORK(&dev->rx_work1, process_rx_w1); + INIT_LIST_HEAD(&dev->tx_reqs); + INIT_LIST_HEAD(&dev->rx_reqs); + +@@ -1352,16 +999,6 @@ int gether_get_ifname(struct net_device *net, char *name, int len) + } + EXPORT_SYMBOL_GPL(gether_get_ifname); + +-void gether_update_dl_max_xfer_size(struct gether *link, uint32_t s) +-{ +- struct eth_dev *dev = link->ioport; +- unsigned long flags; +- +- spin_lock_irqsave(&dev->lock, flags); +- dev->dl_max_xfer_size = s; +- spin_unlock_irqrestore(&dev->lock, flags); +-} +- + /** + * gether_cleanup - remove Ethernet-over-USB device + * Context: may sleep +@@ -1402,13 +1039,6 @@ struct net_device *gether_connect(struct gether *link) + + if (!dev) + return ERR_PTR(-EINVAL); +- link->header = kzalloc(sizeof(struct rndis_packet_msg_type), +- GFP_ATOMIC); +- if (!link->header) { +- result = -ENOMEM; +- goto fail; +- } +- U_ETHER_DBG("\n"); + + link->in_ep->driver_data = dev; + result = usb_ep_enable(link->in_ep); +@@ -1437,14 +1067,8 @@ struct net_device *gether_connect(struct gether *link) + dev->header_len = link->header_len; + dev->unwrap = link->unwrap; + dev->wrap = link->wrap; +- dev->ul_max_pkts_per_xfer = link->ul_max_pkts_per_xfer; +- dev->dl_max_pkts_per_xfer = link->dl_max_pkts_per_xfer; +- dev->dl_max_xfer_size = link->dl_max_transfer_len; + + spin_lock(&dev->lock); +- dev->tx_skb_hold_count = 0; +- dev->no_tx_req_used = 0; +- dev->tx_req_bufsize = 0; + dev->port_usb = link; + if (netif_running(dev->net)) { + if (link->open) +@@ -1465,13 +1089,10 @@ struct net_device *gether_connect(struct gether *link) + fail1: + (void) usb_ep_disable(link->in_ep); + } +- /* caller is responsible for cleanup on error */ +- if (result < 0) { + fail0: +- kfree(link->header); +-fail: ++ /* caller is responsible for cleanup on error */ ++ if (result < 0) + return ERR_PTR(result); +- } + return dev->net; + } + EXPORT_SYMBOL_GPL(gether_connect); +@@ -1492,25 +1113,12 @@ void gether_disconnect(struct gether *link) + { + struct eth_dev *dev = link->ioport; + struct usb_request *req; +- struct sk_buff *skb; + + WARN_ON(!dev); + if (!dev) + return; + +- U_ETHER_DBG("\n"); +- +- rndis_test_rx_usb_in = 0; +- rndis_test_rx_net_out = 0; +- rndis_test_rx_nomem = 0; +- rndis_test_rx_error = 0; +- +- rndis_test_tx_net_in = 0; +- rndis_test_tx_busy = 0; +- rndis_test_tx_stop = 0; +- +- rndis_test_tx_usb_out = 0; +- rndis_test_tx_complete = 0; ++ DBG(dev, "%s\n", __func__); + + netif_stop_queue(dev->net); + netif_carrier_off(dev->net); +@@ -1527,37 +1135,25 @@ void gether_disconnect(struct gether *link) + list_del(&req->list); + + spin_unlock(&dev->req_lock); +- if (link->multi_pkt_xfer) { +- kfree(req->buf); +- req->buf = NULL; +- } + usb_ep_free_request(link->in_ep, req); + spin_lock(&dev->req_lock); + } +- kfree(link->header); +- link->header = NULL; + spin_unlock(&dev->req_lock); + link->in_ep->driver_data = NULL; + link->in_ep->desc = NULL; + + usb_ep_disable(link->out_ep); +- spin_lock(&dev->reqrx_lock); ++ spin_lock(&dev->req_lock); + while (!list_empty(&dev->rx_reqs)) { + req = container_of(dev->rx_reqs.next, + struct usb_request, list); + list_del(&req->list); + +- spin_unlock(&dev->reqrx_lock); ++ spin_unlock(&dev->req_lock); + usb_ep_free_request(link->out_ep, req); +- spin_lock(&dev->reqrx_lock); ++ spin_lock(&dev->req_lock); + } +- spin_unlock(&dev->reqrx_lock); +- +- spin_lock(&dev->rx_frames.lock); +- while ((skb = __skb_dequeue(&dev->rx_frames))) +- dev_kfree_skb_any(skb); +- spin_unlock(&dev->rx_frames.lock); +- ++ spin_unlock(&dev->req_lock); + link->out_ep->driver_data = NULL; + link->out_ep->desc = NULL; + +@@ -1572,30 +1168,5 @@ void gether_disconnect(struct gether *link) + } + EXPORT_SYMBOL_GPL(gether_disconnect); + +-static int __init gether_init(void) +-{ +- uether_wq = create_singlethread_workqueue("uether"); +- if (!uether_wq) { +- pr_err("%s: Unable to create workqueue: uether\n", __func__); +- return -ENOMEM; +- } +- uether_wq1 = create_singlethread_workqueue("uether_rx1"); +- if (!uether_wq1) { +- destroy_workqueue(uether_wq); +- pr_err("%s: Unable to create workqueue: uether\n", __func__); +- return -ENOMEM; +- } +- return 0; +-} +-module_init(gether_init); +- +-static void __exit gether_exit(void) +-{ +- destroy_workqueue(uether_wq); +- destroy_workqueue(uether_wq1); +- +-} +-module_exit(gether_exit); ++MODULE_LICENSE("GPL"); + MODULE_AUTHOR("David Brownell"); +-MODULE_DESCRIPTION("ethernet over USB driver"); +-MODULE_LICENSE("GPL v2"); +diff --git a/drivers/usb/gadget/function/u_ether.h b/drivers/usb/gadget/function/u_ether.h +index 22d82976ed8a..334b38947916 100644 +--- a/drivers/usb/gadget/function/u_ether.h ++++ b/drivers/usb/gadget/function/u_ether.h +@@ -22,7 +22,7 @@ + + #include "gadget_chips.h" + +-#define QMULT_DEFAULT 10 ++#define QMULT_DEFAULT 5 + + /* + * dev_addr: initial value +@@ -35,11 +35,11 @@ + MODULE_PARM_DESC(qmult, "queue length multiplier at high/super speed");\ + \ + static char *dev_addr; \ +- module_param(dev_addr, charp, S_IRUGO|S_IWUSR); \ ++ module_param(dev_addr, charp, S_IRUGO); \ + MODULE_PARM_DESC(dev_addr, "Device Ethernet Address"); \ + \ + static char *host_addr; \ +- module_param(host_addr, charp, S_IRUGO|S_IWUSR); \ ++ module_param(host_addr, charp, S_IRUGO); \ + MODULE_PARM_DESC(host_addr, "Host Ethernet Address") + + struct eth_dev; +@@ -75,10 +75,6 @@ struct gether { + bool is_fixed; + u32 fixed_out_len; + u32 fixed_in_len; +- unsigned ul_max_pkts_per_xfer; +- unsigned dl_max_pkts_per_xfer; +- unsigned dl_max_transfer_len; +- bool multi_pkt_xfer; + bool supports_multi_frame; + struct sk_buff *(*wrap)(struct gether *port, + struct sk_buff *skb); +@@ -89,7 +85,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 \ +@@ -260,7 +255,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) +@@ -275,21 +269,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_usb_out; +-extern unsigned long rndis_test_tx_complete; +- + #endif /* __U_ETHER_H */ + \ No newline at end of file diff --git a/device/linux-nokia-frt/APKBUILD b/device/linux-nokia-frt/APKBUILD index fdb295b5a..9ab37b1f8 100644 --- a/device/linux-nokia-frt/APKBUILD +++ b/device/linux-nokia-frt/APKBUILD @@ -4,7 +4,7 @@ maintainer="Piotr Halama " pkgname="linux-nokia-frt" pkgver=3.18.79 -pkgrel=0 +pkgrel=1 pkgdesc="Nokia 1 kernel fork" arch="armv7" _carch="arm" @@ -20,15 +20,15 @@ HOSTCC="${HOSTCC#${CROSS_COMPILE}}" # Source _repository="android_kernel_nokia_1" -_commit="f17e3dc43479ed748f85080e5be04be228ed754d" +_commit="588ea962d4c9c21d20a7109273587e49c7da9235" _config="config-${_flavor}.${arch}" source=" $pkgname-$_commit.tar.gz::https://github.com/pmsourcedump/${_repository}/archive/${_commit}.tar.gz $_config gcc8-fix-put-user.patch - 00_makefile_path.patch - 01_drvgen_mk.patch - 02_path_fixes.patch + 00_symlinks.patch + 01_makefile_path.patch + 02_drvgen_mk.patch 03_vdsomunge_upstream.patch " #gcc7-give-up-on-ilog2-const-optimizations.patch @@ -73,10 +73,10 @@ package() { modules_install } -sha512sums="d9026958c7f9cb7dbc56b27baab3362d6a34e975ebf933e8ee404dc76638d17fd3d2508f262f10190f646a0881d68ab0e0a40f2fce15a55409527f3af8ea9d19 linux-nokia-frt-f17e3dc43479ed748f85080e5be04be228ed754d.tar.gz +sha512sums="676be1813c0886c509591a4940b9fdbd91243aaf84a8efebd7229f681e84211d86cc3466079808eb2fba45c0ada4bc7d43a4b5ab599326702c1d4830fa16d630 linux-nokia-frt-588ea962d4c9c21d20a7109273587e49c7da9235.tar.gz 4e4c05f4095c0490bb04b262b19033adda7d95fdec5c6c5bf1ba4b2cfa812ff159c9637f9cb6a3e854b46923467e9559d39b8b2b81f6fe6d038a6dbf5961c303 config-nokia-frt.armv7 197d40a214ada87fcb2dfc0ae4911704b9a93354b75179cd6b4aadbb627a37ec262cf516921c84a8b1806809b70a7b440cdc8310a4a55fca5d2c0baa988e3967 gcc8-fix-put-user.patch -ef8b9da80ca67424a02acfbf99924e3ea06574c83c6a737031f6ac41b718742ef0bd66b968b14118cac021067e29184e2199f238ace2a43dc2176d9cce796bc5 00_makefile_path.patch -aaf7e208f307db3126202f3f3410d4f8a74b450ef719717a064c817258cb428a150a798494f57e43f9e1f747ad83527e565f8d81c3c746d1fb0b4e42e6e30d50 01_drvgen_mk.patch -bba77598f2fc5615b21f98db7e6a43a35d9cfae0e10fb8754d3b3c198ed36def390937c766550e251ae6c9867145e13dd0d1977bc8cc259ac53e48fedc4d0fee 02_path_fixes.patch -2bd2706f7b42a313e81bf27726ef697f0292f8f2c53ded5d344d410d25fc02375ea9659c7dab93500d4966e91efb0658d6ecf3292196350159e2cd54ed78441e 03_vdsomunge_upstream.patch" +1d1a99de49b29069eb1711ad884e3f0db0956d8eeb81bdb332e6aa13fb7f5cdd48cd75791cebc08b1aa0644cdd643d7632791a272333547a6ffe68a75295e7a8 00_symlinks.patch +ef8b9da80ca67424a02acfbf99924e3ea06574c83c6a737031f6ac41b718742ef0bd66b968b14118cac021067e29184e2199f238ace2a43dc2176d9cce796bc5 01_makefile_path.patch +aaf7e208f307db3126202f3f3410d4f8a74b450ef719717a064c817258cb428a150a798494f57e43f9e1f747ad83527e565f8d81c3c746d1fb0b4e42e6e30d50 02_drvgen_mk.patch +19a6c3445bfd8057e4fabe1709f3d2344f3a99fef49b44636c07a18ba8791fab1bcff77f93aadff887946ae6f83c9d86e1c28f9b88d03c6ba156704d430b4470 03_vdsomunge_upstream.patch"