Merge branch 'cdc_ncm'

Bjørn Mork says:

====================
cdc_ncm: many small and mostly trivial fixes

This series ended up longer than expected, and it is still not
complete. There is more to come when time allows...

Most changes are trivial. Notable non-trivial changes are
 - removed filtering of identical speed notifications
 - tx_max calulation is changed to count the pad byte if
   necessary, and respect the device limit as an absolute
   upper limit even if it is too low according to the spec
 - remove the bug preventing SET_MAX_DATAGRAM_SIZE from having
   any effect
 - drop the pad-to-max if ZLPs are enabled
 - the driver specific VERSION is dropped
 - dev->hard_mtu is set to tx_max instead of max_datagram_size
   causing usbnet to calculate the qlen based on the real max
   size of tx skbs

This series has been tested, along with the previously posted
cdc_mbim series, on the NCM and MBIM devices I have:
 - Ericsson F5521gw (NCM)
 - Huawei E367 (MBIM)
 - D-Link DWM-156 A7 (MBIM w/ too low dwNtb{In,Out}MaxSize bug)
 - Sierra Wireless MC7710 (MBIM w/ ZLP and CDC Union bugs)

Apart from the D-Link modem dropping a lot less oversized
frames with the fix dedicated to it, there are no end user
noticable functional changes as a result of this series.  But
all the non-trivial changes I listed above are of course
detectable by users looking at that specific area (except maybe
the removed speed notification, which requires a device sending
duplicates to be noticable - I don't have any such device).
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

3 files changed, 233 insertions, 289 deletions

diff --git a/drivers/net/usb/cdc_mbim.c b/drivers/net/usb/cdc_mbim.c
index 253472a8a983..af76aaf08b6b 100644
--- a/drivers/net/usb/cdc_mbim.c
+++ b/drivers/net/usb/cdc_mbim.c
@@ -175,7 +175,7 @@ static struct sk_buff *cdc_mbim_tx_fixup(struct usbnet *dev, struct sk_buff *skb
         }
 
         spin_lock_bh(&ctx->mtx);
-        skb_out = cdc_ncm_fill_tx_frame(ctx, skb, sign);
+        skb_out = cdc_ncm_fill_tx_frame(dev, skb, sign);
         spin_unlock_bh(&ctx->mtx);
         return skb_out;
 
diff --git a/drivers/net/usb/cdc_ncm.c b/drivers/net/usb/cdc_ncm.c
index 43afde8f48d2..11c703337577 100644
--- a/drivers/net/usb/cdc_ncm.c
+++ b/drivers/net/usb/cdc_ncm.c
@@ -53,8 +53,6 @@
 #include <linux/usb/cdc.h>
 #include <linux/usb/cdc_ncm.h>
 
-#define DRIVER_VERSION                          "14-Mar-2012"
-
 #if IS_ENABLED(CONFIG_USB_NET_CDC_MBIM)
 static bool prefer_mbim = true;
 #else
@@ -68,71 +66,67 @@ static void cdc_ncm_tx_timeout_start(struct cdc_ncm_ctx *ctx);
 static enum hrtimer_restart cdc_ncm_tx_timer_cb(struct hrtimer *hr_timer);
 static struct usb_driver cdc_ncm_driver;
 
-static void
-cdc_ncm_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info)
-{
-        struct usbnet *dev = netdev_priv(net);
-
-        strlcpy(info->driver, dev->driver_name, sizeof(info->driver));
-        strlcpy(info->version, DRIVER_VERSION, sizeof(info->version));
-        strlcpy(info->fw_version, dev->driver_info->description,
-                sizeof(info->fw_version));
-        usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
-}
-
-static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
+static u8 cdc_ncm_setup(struct usbnet *dev)
 {
+        struct cdc_ncm_ctx *ctx = (struct cdc_ncm_ctx *)dev->data[0];
+        struct usb_cdc_ncm_ntb_parameters ncm_parm;
         u32 val;
         u8 flags;
         u8 iface_no;
         int err;
         int eth_hlen;
         u16 ntb_fmt_supported;
-        u32 min_dgram_size;
-        u32 min_hdr_size;
-        struct usbnet *dev = netdev_priv(ctx->netdev);
+        __le16 max_datagram_size;
 
         iface_no = ctx->control->cur_altsetting->desc.bInterfaceNumber;
 
         err = usbnet_read_cmd(dev, USB_CDC_GET_NTB_PARAMETERS,
                               USB_TYPE_CLASS | USB_DIR_IN
                               |USB_RECIP_INTERFACE,
-                              0, iface_no, &ctx->ncm_parm,
-                              sizeof(ctx->ncm_parm));
+                              0, iface_no, &ncm_parm,
+                              sizeof(ncm_parm));
         if (err < 0) {
-                pr_debug("failed GET_NTB_PARAMETERS\n");
-                return 1;
+                dev_err(&dev->intf->dev, "failed GET_NTB_PARAMETERS\n");
+                return err; /* GET_NTB_PARAMETERS is required */
         }
 
         /* read correct set of parameters according to device mode */
-        ctx->rx_max = le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize);
-        ctx->tx_max = le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize);
-        ctx->tx_remainder = le16_to_cpu(ctx->ncm_parm.wNdpOutPayloadRemainder);
-        ctx->tx_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutDivisor);
-        ctx->tx_ndp_modulus = le16_to_cpu(ctx->ncm_parm.wNdpOutAlignment);
+        ctx->rx_max = le32_to_cpu(ncm_parm.dwNtbInMaxSize);
+        ctx->tx_max = le32_to_cpu(ncm_parm.dwNtbOutMaxSize);
+        ctx->tx_remainder = le16_to_cpu(ncm_parm.wNdpOutPayloadRemainder);
+        ctx->tx_modulus = le16_to_cpu(ncm_parm.wNdpOutDivisor);
+        ctx->tx_ndp_modulus = le16_to_cpu(ncm_parm.wNdpOutAlignment);
         /* devices prior to NCM Errata shall set this field to zero */
-        ctx->tx_max_datagrams = le16_to_cpu(ctx->ncm_parm.wNtbOutMaxDatagrams);
-        ntb_fmt_supported = le16_to_cpu(ctx->ncm_parm.bmNtbFormatsSupported);
+        ctx->tx_max_datagrams = le16_to_cpu(ncm_parm.wNtbOutMaxDatagrams);
+        ntb_fmt_supported = le16_to_cpu(ncm_parm.bmNtbFormatsSupported);
 
-        eth_hlen = ETH_HLEN;
-        min_dgram_size = CDC_NCM_MIN_DATAGRAM_SIZE;
-        min_hdr_size = CDC_NCM_MIN_HDR_SIZE;
-        if (ctx->mbim_desc != NULL) {
-                flags = ctx->mbim_desc->bmNetworkCapabilities;
+        /* there are some minor differences in NCM and MBIM defaults */
+        if (cdc_ncm_comm_intf_is_mbim(ctx->control->cur_altsetting)) {
+                if (!ctx->mbim_desc)
+                        return -EINVAL;
                 eth_hlen = 0;
-                min_dgram_size = CDC_MBIM_MIN_DATAGRAM_SIZE;
-                min_hdr_size = 0;
-        } else if (ctx->func_desc != NULL) {
-                flags = ctx->func_desc->bmNetworkCapabilities;
+                flags = ctx->mbim_desc->bmNetworkCapabilities;
+                ctx->max_datagram_size = le16_to_cpu(ctx->mbim_desc->wMaxSegmentSize);
+                if (ctx->max_datagram_size < CDC_MBIM_MIN_DATAGRAM_SIZE)
+                        ctx->max_datagram_size = CDC_MBIM_MIN_DATAGRAM_SIZE;
         } else {
-                flags = 0;
+                if (!ctx->func_desc)
+                        return -EINVAL;
+                eth_hlen = ETH_HLEN;
+                flags = ctx->func_desc->bmNetworkCapabilities;
+                ctx->max_datagram_size = le16_to_cpu(ctx->ether_desc->wMaxSegmentSize);
+                if (ctx->max_datagram_size < CDC_NCM_MIN_DATAGRAM_SIZE)
+                        ctx->max_datagram_size = CDC_NCM_MIN_DATAGRAM_SIZE;
         }
 
-        pr_debug("dwNtbInMaxSize=%u dwNtbOutMaxSize=%u "
-                 "wNdpOutPayloadRemainder=%u wNdpOutDivisor=%u "
-                 "wNdpOutAlignment=%u wNtbOutMaxDatagrams=%u flags=0x%x\n",
-                 ctx->rx_max, ctx->tx_max, ctx->tx_remainder, ctx->tx_modulus,
-                 ctx->tx_ndp_modulus, ctx->tx_max_datagrams, flags);
+        /* common absolute max for NCM and MBIM */
+        if (ctx->max_datagram_size > CDC_NCM_MAX_DATAGRAM_SIZE)
+                ctx->max_datagram_size = CDC_NCM_MAX_DATAGRAM_SIZE;
+
+        dev_dbg(&dev->intf->dev,
+                "dwNtbInMaxSize=%u dwNtbOutMaxSize=%u wNdpOutPayloadRemainder=%u wNdpOutDivisor=%u wNdpOutAlignment=%u wNtbOutMaxDatagrams=%u flags=0x%x\n",
+                ctx->rx_max, ctx->tx_max, ctx->tx_remainder, ctx->tx_modulus,
+                ctx->tx_ndp_modulus, ctx->tx_max_datagrams, flags);
 
         /* max count of tx datagrams */
         if ((ctx->tx_max_datagrams == 0) ||
@@ -141,19 +135,19 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)
 
         /* verify maximum size of received NTB in bytes */
         if (ctx->rx_max < USB_CDC_NCM_NTB_MIN_IN_SIZE) {
-                pr_debug("Using min receive length=%d\n",
-                                                USB_CDC_NCM_NTB_MIN_IN_SIZE);
+                dev_dbg(&dev->intf->dev, "Using min receive length=%d\n",
+                        USB_CDC_NCM_NTB_MIN_IN_SIZE);
                 ctx->rx_max = USB_CDC_NCM_NTB_MIN_IN_SIZE;
         }
 
         if (ctx->rx_max > CDC_NCM_NTB_MAX_SIZE_RX) {
-                pr_debug("Using default maximum receive length=%d\n",
-                                                CDC_NCM_NTB_MAX_SIZE_RX);
+                dev_dbg(&dev->intf->dev, "Using default maximum receive length=%d\n",
+                        CDC_NCM_NTB_MAX_SIZE_RX);
                 ctx->rx_max = CDC_NCM_NTB_MAX_SIZE_RX;
         }
 
         /* inform device about NTB input size changes */
-        if (ctx->rx_max != le32_to_cpu(ctx->ncm_parm.dwNtbInMaxSize)) {
+        if (ctx->rx_max != le32_to_cpu(ncm_parm.dwNtbInMaxSize)) {
                 __le32 dwNtbInMaxSize = cpu_to_le32(ctx->rx_max);
 
                 err = usbnet_write_cmd(dev, USB_CDC_SET_NTB_INPUT_SIZE,
@@ -161,16 +155,22 @@ static u8 cdc_ncm_setup(struct cdc_ncm_ctx *ctx)