5 files changed, 253 insertions, 13 deletions

diff --git a/drivers/net/usb/Kconfig b/drivers/net/usb/Kconfig
index 40db31233313..85e4a01670f0 100644
--- a/drivers/net/usb/Kconfig
+++ b/drivers/net/usb/Kconfig
@@ -242,6 +242,21 @@ config USB_NET_CDC_NCM
             * ST-Ericsson M343 HSPA Mobile Broadband Modem (reference design)
             * Ericsson F5521gw Mobile Broadband Module
 
+config USB_NET_HUAWEI_CDC_NCM
+        tristate "Huawei NCM embedded AT channel support"
+        depends on USB_USBNET
+        select USB_WDM
+        select USB_NET_CDC_NCM
+        help
+                This driver supports huawei-style NCM devices, that use NCM as a
+                transport for other protocols, usually an embedded AT channel.
+                Good examples are:
+                * Huawei E3131
+                * Huawei E3251
+
+                To compile this driver as a module, choose M here: the module will be
+                called huawei_cdc_ncm.ko.
+
 config USB_NET_CDC_MBIM
         tristate "CDC MBIM support"
         depends on USB_USBNET
diff --git a/drivers/net/usb/Makefile b/drivers/net/usb/Makefile
index 8b342cf992fd..b17b5e88bbaf 100644
--- a/drivers/net/usb/Makefile
+++ b/drivers/net/usb/Makefile
@@ -32,6 +32,7 @@ obj-$(CONFIG_USB_IPHETH)	+= ipheth.o
 obj-$(CONFIG_USB_SIERRA_NET)    += sierra_net.o
 obj-$(CONFIG_USB_NET_CX82310_ETH)       += cx82310_eth.o
 obj-$(CONFIG_USB_NET_CDC_NCM)   += cdc_ncm.o
+obj-$(CONFIG_USB_NET_HUAWEI_CDC_NCM)    += huawei_cdc_ncm.o
 obj-$(CONFIG_USB_VL600)         += lg-vl600.o
 obj-$(CONFIG_USB_NET_QMI_WWAN)  += qmi_wwan.o
 obj-$(CONFIG_USB_NET_CDC_MBIM)  += cdc_mbim.o
diff --git a/drivers/net/usb/cdc_ncm.c b/drivers/net/usb/cdc_ncm.c
index 11c703337577..f74786aa37be 100644
--- a/drivers/net/usb/cdc_ncm.c
+++ b/drivers/net/usb/cdc_ncm.c
@@ -830,7 +830,7 @@ static void cdc_ncm_txpath_bh(unsigned long param)
         }
 }
 
-static struct sk_buff *
+struct sk_buff *
 cdc_ncm_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
 {
         struct sk_buff *skb_out;
@@ -857,6 +857,7 @@ error:
 
         return NULL;
 }
+EXPORT_SYMBOL_GPL(cdc_ncm_tx_fixup);
 
 /* verify NTB header and return offset of first NDP, or negative error */
 int cdc_ncm_rx_verify_nth16(struct cdc_ncm_ctx *ctx, struct sk_buff *skb_in)
@@ -943,7 +944,7 @@ error:
 }
 EXPORT_SYMBOL_GPL(cdc_ncm_rx_verify_ndp16);
 
-static int cdc_ncm_rx_fixup(struct usbnet *dev, struct sk_buff *skb_in)
+int cdc_ncm_rx_fixup(struct usbnet *dev, struct sk_buff *skb_in)
 {
         struct sk_buff *skb;
         struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
@@ -1019,6 +1020,7 @@ err_ndp:
 error:
         return 0;
 }
+EXPORT_SYMBOL_GPL(cdc_ncm_rx_fixup);
 
 static void
 cdc_ncm_speed_change(struct usbnet *dev,
@@ -1184,17 +1186,6 @@ static const struct usb_device_id cdc_devs[] = {
           .driver_info = (unsigned long)&wwan_info,
         },
 
-        /* Huawei NCM devices disguised as vendor specific */
-        { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x16),
-          .driver_info = (unsigned long)&wwan_info,
-        },
-        { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x46),
-          .driver_info = (unsigned long)&wwan_info,
-        },
-        { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x76),
-          .driver_info = (unsigned long)&wwan_info,
-        },
-
         /* Infineon(now Intel) HSPA Modem platform */
         { USB_DEVICE_AND_INTERFACE_INFO(0x1519, 0x0443,
                 USB_CLASS_COMM,
diff --git a/drivers/net/usb/huawei_cdc_ncm.c b/drivers/net/usb/huawei_cdc_ncm.c
new file mode 100644
index 000000000000..312178d7b698
--- /dev/null
+++ b/drivers/net/usb/huawei_cdc_ncm.c
@@ -0,0 +1,230 @@
+/* huawei_cdc_ncm.c - handles Huawei devices using the CDC NCM protocol as
+ * transport layer.
+ * Copyright (C) 2013    Enrico Mioso <mrkiko.rs@gmail.com>
+ *
+ *
+ * ABSTRACT:
+ * This driver handles devices resembling the CDC NCM standard, but
+ * encapsulating another protocol inside it. An example are some Huawei 3G
+ * devices, exposing an embedded AT channel where you can set up the NCM
+ * connection.
+ * This code has been heavily inspired by the cdc_mbim.c driver, which is
+ * Copyright (c) 2012  Smith Micro Software, Inc.
+ * Copyright (c) 2012  Bjørn Mork <bjorn@mork.no>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/netdevice.h>
+#include <linux/ethtool.h>
+#include <linux/if_vlan.h>
+#include <linux/ip.h>
+#include <linux/mii.h>
+#include <linux/usb.h>
+#include <linux/usb/cdc.h>
+#include <linux/usb/usbnet.h>
+#include <linux/usb/cdc-wdm.h>
+#include <linux/usb/cdc_ncm.h>
+
+/* Driver data */
+struct huawei_cdc_ncm_state {
+        struct cdc_ncm_ctx *ctx;
+        atomic_t pmcount;
+        struct usb_driver *subdriver;
+        struct usb_interface *control;
+        struct usb_interface *data;
+};
+
+static int huawei_cdc_ncm_manage_power(struct usbnet *usbnet_dev, int on)
+{
+        struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
+        int rv;
+
+        if ((on && atomic_add_return(1, &drvstate->pmcount) == 1) ||
+                        (!on && atomic_dec_and_test(&drvstate->pmcount))) {
+                rv = usb_autopm_get_interface(usbnet_dev->intf);
+                usbnet_dev->intf->needs_remote_wakeup = on;
+                if (!rv)
+                        usb_autopm_put_interface(usbnet_dev->intf);
+        }
+        return 0;
+}
+
+static int huawei_cdc_ncm_wdm_manage_power(struct usb_interface *intf,
+                                           int status)
+{
+        struct usbnet *usbnet_dev = usb_get_intfdata(intf);
+
+        /* can be called while disconnecting */
+        if (!usbnet_dev)
+                return 0;
+
+        return huawei_cdc_ncm_manage_power(usbnet_dev, status);
+}
+
+
+static int huawei_cdc_ncm_bind(struct usbnet *usbnet_dev,
+                               struct usb_interface *intf)
+{
+        struct cdc_ncm_ctx *ctx;
+        struct usb_driver *subdriver = ERR_PTR(-ENODEV);
+        int ret = -ENODEV;
+        struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
+
+        /* altsetting should always be 1 for NCM devices - so we hard-coded
+         * it here
+         */
+        ret = cdc_ncm_bind_common(usbnet_dev, intf, 1);
+        if (ret)
+                goto err;
+
+        ctx = drvstate->ctx;
+
+        if (usbnet_dev->status)
+                /* CDC-WMC r1.1 requires wMaxCommand to be "at least 256
+                 * decimal (0x100)"
+                 */
+                subdriver = usb_cdc_wdm_register(ctx->control,
+                                                 &usbnet_dev->status->desc,
+                                                 256, /* wMaxCommand */
+                                                 huawei_cdc_ncm_wdm_manage_power);
+        if (IS_ERR(subdriver)) {
+                ret = PTR_ERR(subdriver);
+                cdc_ncm_unbind(usbnet_dev, intf);
+                goto err;
+        }
+
+        /* Prevent usbnet from using the status descriptor */
+        usbnet_dev->status = NULL;
+
+        drvstate->subdriver = subdriver;
+
+err:
+        return ret;
+}
+
+static void huawei_cdc_ncm_unbind(struct usbnet *usbnet_dev,
+                                  struct usb_interface *intf)
+{
+        struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
+        struct cdc_ncm_ctx *ctx = drvstate->ctx;
+
+        if (drvstate->subdriver && drvstate->subdriver->disconnect)
+                drvstate->subdriver->disconnect(ctx->control);
+        drvstate->subdriver = NULL;
+
+        cdc_ncm_unbind(usbnet_dev, intf);
+}
+
+static int huawei_cdc_ncm_suspend(struct usb_interface *intf,
+                                  pm_message_t message)
+{
+        int ret = 0;
+        struct usbnet *usbnet_dev = usb_get_intfdata(intf);
+        struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
+        struct cdc_ncm_ctx *ctx = drvstate->ctx;
+
+        if (ctx == NULL) {
+                ret = -ENODEV;
+                goto error;
+        }
+
+        ret = usbnet_suspend(intf, message);
+        if (ret < 0)
+                goto error;
+
+        if (intf == ctx->control &&
+                drvstate->subdriver &&
+                drvstate->subdriver->suspend)
+                ret = drvstate->subdriver->suspend(intf, message);
+        if (ret < 0)
+                usbnet_resume(intf);
+
+error:
+        return ret;
+}
+
+static int huawei_cdc_ncm_resume(struct usb_interface *intf)
+{
+        int ret = 0;
+        struct usbnet *usbnet_dev = usb_get_intfdata(intf);
+        struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
+        bool callsub;
+        struct cdc_ncm_ctx *ctx = drvstate->ctx;
+
+        /* should we call subdriver's resume function? */
+        callsub =
+                (intf == ctx->control &&
+                drvstate->subdriver &&
+                drvstate->subdriver->resume);
+
+        if (callsub)
+                ret = drvstate->subdriver->resume(intf);
+        if (ret < 0)
+                goto err;
+        ret = usbnet_resume(intf);
+        if (ret < 0 && callsub)
+                drvstate->subdriver->suspend(intf, PMSG_SUSPEND);
+err:
+        return ret;
+}
+
+static int huawei_cdc_ncm_check_connect(struct usbnet *usbnet_dev)
+{
+        struct cdc_ncm_ctx *ctx;
+
+        ctx = (struct cdc_ncm_ctx *)usbnet_dev->data[0];
+
+        if (ctx == NULL)
+                return 1; /* disconnected */
+
+        return !ctx->connected;
+}
+
+static const struct driver_info huawei_cdc_ncm_info = {
+        .description = "Huawei CDC NCM device",
+        .flags = FLAG_NO_SETINT | FLAG_MULTI_PACKET | FLAG_WWAN,
+        .bind = huawei_cdc_ncm_bind,
+        .unbind = huawei_cdc_ncm_unbind,
+        .check_connect = huawei_cdc_ncm_check_connect,
+        .manage_power = huawei_cdc_ncm_manage_power,
+        .rx_fixup = cdc_ncm_rx_fixup,
+        .tx_fixup = cdc_ncm_tx_fixup,
+};
+
+static const struct usb_device_id huawei_cdc_ncm_devs[] = {
+        /* Huawei NCM devices disguised as vendor specific */
+        { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x16),
+          .driver_info = (unsigned long)&huawei_cdc_ncm_info,
+        },
+        { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x46),
+          .driver_info = (unsigned long)&huawei_cdc_ncm_info,
+        },
+        { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x76),
+          .driver_info = (unsigned long)&huawei_cdc_ncm_info,
+        },
+
+        /* Terminating entry */
+        {
+        },
+};
+MODULE_DEVICE_TABLE(usb, huawei_cdc_ncm_devs);
+
+static struct usb_driver huawei_cdc_ncm_driver = {
+        .name = "huawei_cdc_ncm",
+        .id_table = huawei_cdc_ncm_devs,
+        .probe = usbnet_probe,
+        .disconnect = usbnet_disconnect,
+        .suspend = huawei_cdc_ncm_suspend,
+        .resume = huawei_cdc_ncm_resume,
+        .reset_resume = huawei_cdc_ncm_resume,
+        .supports_autosuspend = 1,
+        .disable_hub_initiated_lpm = 1,
+};
+module_usb_driver(huawei_cdc_ncm_driver);
+MODULE_AUTHOR("Enrico Mioso <mrkiko.rs@gmail.com>");
+MODULE_DESCRIPTION("USB CDC NCM host driver with encapsulated protocol support");
+MODULE_LICENSE("GPL");
diff --git a/include/linux/usb/cdc_ncm.h b/include/linux/usb/cdc_ncm.h
index 2300f7492927..c3fa80745996 100644
--- a/include/linux/usb/cdc_ncm.h
+++ b/include/linux/usb/cdc_ncm.h
@@ -125,5 +125,8 @@ void cdc_ncm_unbind(struct usbnet *dev, struct usb_interface *intf);
 struct sk_buff *cdc_ncm_fill_tx_frame(struct usbnet *dev, struct sk_buff *skb, __le32 sign);
 int cdc_ncm_rx_verify_nth16(struct cdc_ncm_ctx *ctx, struct sk_buff *skb_in);
 int cdc_ncm_rx_verify_ndp16(struct sk_buff *skb_in, int ndpoffset);
+struct sk_buff *
+cdc_ncm_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags);
+int cdc_ncm_rx_fixup(struct usbnet *dev, struct sk_buff *skb_in);
 
 #endif /* __LINUX_USB_CDC_NCM_H */