drivers/net/usb/huawei_cdc_ncm.c

   1 /* huawei_cdc_ncm.c - handles Huawei devices using the CDC NCM protocol as
   2  * transport layer.
   3  * Copyright (C) 2013    Enrico Mioso <mrkiko.rs@gmail.com>
   4  *
   5  *
   6  * ABSTRACT:
   7  * This driver handles devices resembling the CDC NCM standard, but
   8  * encapsulating another protocol inside it. An example are some Huawei 3G
   9  * devices, exposing an embedded AT channel where you can set up the NCM
  10  * connection.
  11  * This code has been heavily inspired by the cdc_mbim.c driver, which is
  12  * Copyright (c) 2012  Smith Micro Software, Inc.
  13  * Copyright (c) 2012  Bjørn Mork <bjorn@mork.no>
  14  *
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License
  17  * version 2 as published by the Free Software Foundation.
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/netdevice.h>
  22 #include <linux/ethtool.h>
  23 #include <linux/if_vlan.h>
  24 #include <linux/ip.h>
  25 #include <linux/mii.h>
  26 #include <linux/usb.h>
  27 #include <linux/usb/cdc.h>
  28 #include <linux/usb/usbnet.h>
  29 #include <linux/usb/cdc-wdm.h>
  30 #include <linux/usb/cdc_ncm.h>
  31
  32 /* Driver data */
  33 struct huawei_cdc_ncm_state {
  34         struct cdc_ncm_ctx *ctx;
  35         atomic_t pmcount;
  36         struct usb_driver *subdriver;
  37         struct usb_interface *control;
  38         struct usb_interface *data;
  39 };
  40
  41 static int huawei_cdc_ncm_manage_power(struct usbnet *usbnet_dev, int on)
  42 {
  43         struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
  44         int rv;
  45
  46         if ((on && atomic_add_return(1, &drvstate->pmcount) == 1) ||
  47                         (!on && atomic_dec_and_test(&drvstate->pmcount))) {
  48                 rv = usb_autopm_get_interface(usbnet_dev->intf);
  49                 usbnet_dev->intf->needs_remote_wakeup = on;
  50                 if (!rv)
  51                         usb_autopm_put_interface(usbnet_dev->intf);
  52         }
  53         return 0;
  54 }
  55
  56 static int huawei_cdc_ncm_wdm_manage_power(struct usb_interface *intf,
  57                                            int status)
  58 {
  59         struct usbnet *usbnet_dev = usb_get_intfdata(intf);
  60
  61         /* can be called while disconnecting */
  62         if (!usbnet_dev)
  63                 return 0;
  64
  65         return huawei_cdc_ncm_manage_power(usbnet_dev, status);
  66 }
  67
  68
  69 static int huawei_cdc_ncm_bind(struct usbnet *usbnet_dev,
  70                                struct usb_interface *intf)
  71 {
  72         struct cdc_ncm_ctx *ctx;
  73         struct usb_driver *subdriver = ERR_PTR(-ENODEV);
  74         int ret = -ENODEV;
  75         struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
  76         int drvflags = 0;
  77
  78         /* altsetting should always be 1 for NCM devices - so we hard-coded
  79          * it here. Some huawei devices will need the NDP part of the NCM package to
  80          * be at the end of the frame.
  81          */
  82         drvflags |= CDC_NCM_FLAG_NDP_TO_END;
  83
  84         /* Additionally, it has been reported that some Huawei E3372H devices, with
  85          * firmware version 21.318.01.00.541, come out of reset in NTB32 format mode, hence
  86          * needing to be set to the NTB16 one again.
  87          */
  88         drvflags |= CDC_NCM_FLAG_RESET_NTB16;
  89         ret = cdc_ncm_bind_common(usbnet_dev, intf, 1, drvflags);
  90         if (ret)
  91                 goto err;
  92
  93         ctx = drvstate->ctx;
  94
  95         if (usbnet_dev->status)
  96                 /* The wMaxCommand buffer must be big enough to hold
  97                  * any message from the modem. Experience has shown
  98                  * that some replies are more than 256 bytes long
  99                  */
 100                 subdriver = usb_cdc_wdm_register(ctx->control,
 101                                                  &usbnet_dev->status->desc,
 102                                                  1024, /* wMaxCommand */
 103                                                  huawei_cdc_ncm_wdm_manage_power);
 104         if (IS_ERR(subdriver)) {
 105                 ret = PTR_ERR(subdriver);
 106                 cdc_ncm_unbind(usbnet_dev, intf);
 107                 goto err;
 108         }
 109
 110         /* Prevent usbnet from using the status descriptor */
 111         usbnet_dev->status = NULL;
 112
 113         drvstate->subdriver = subdriver;
 114
 115 err:
 116         return ret;
 117 }
 118
 119 static void huawei_cdc_ncm_unbind(struct usbnet *usbnet_dev,
 120                                   struct usb_interface *intf)
 121 {
 122         struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
 123         struct cdc_ncm_ctx *ctx = drvstate->ctx;
 124
 125         if (drvstate->subdriver && drvstate->subdriver->disconnect)
 126                 drvstate->subdriver->disconnect(ctx->control);
 127         drvstate->subdriver = NULL;
 128
 129         cdc_ncm_unbind(usbnet_dev, intf);
 130 }
 131
 132 static int huawei_cdc_ncm_suspend(struct usb_interface *intf,
 133                                   pm_message_t message)
 134 {
 135         int ret = 0;
 136         struct usbnet *usbnet_dev = usb_get_intfdata(intf);
 137         struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
 138         struct cdc_ncm_ctx *ctx = drvstate->ctx;
 139
 140         if (ctx == NULL) {
 141                 ret = -ENODEV;
 142                 goto error;
 143         }
 144
 145         ret = usbnet_suspend(intf, message);
 146         if (ret < 0)
 147                 goto error;
 148
 149         if (intf == ctx->control &&
 150                 drvstate->subdriver &&
 151                 drvstate->subdriver->suspend)
 152                 ret = drvstate->subdriver->suspend(intf, message);
 153         if (ret < 0)
 154                 usbnet_resume(intf);
 155
 156 error:
 157         return ret;
 158 }
 159
 160 static int huawei_cdc_ncm_resume(struct usb_interface *intf)
 161 {
 162         int ret = 0;
 163         struct usbnet *usbnet_dev = usb_get_intfdata(intf);
 164         struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
 165         bool callsub;
 166         struct cdc_ncm_ctx *ctx = drvstate->ctx;
 167
 168         /* should we call subdriver's resume function? */
 169         callsub =
 170                 (intf == ctx->control &&
 171                 drvstate->subdriver &&
 172                 drvstate->subdriver->resume);
 173
 174         if (callsub)
 175                 ret = drvstate->subdriver->resume(intf);
 176         if (ret < 0)
 177                 goto err;
 178         ret = usbnet_resume(intf);
 179         if (ret < 0 && callsub)
 180                 drvstate->subdriver->suspend(intf, PMSG_SUSPEND);
 181 err:
 182         return ret;
 183 }
 184
 185 static const struct driver_info huawei_cdc_ncm_info = {
 186         .description = "Huawei CDC NCM device",
 187         .flags = FLAG_NO_SETINT | FLAG_MULTI_PACKET | FLAG_WWAN,
 188         .bind = huawei_cdc_ncm_bind,
 189         .unbind = huawei_cdc_ncm_unbind,
 190         .manage_power = huawei_cdc_ncm_manage_power,
 191         .rx_fixup = cdc_ncm_rx_fixup,
 192         .tx_fixup = cdc_ncm_tx_fixup,
 193 };
 194
 195 static const struct usb_device_id huawei_cdc_ncm_devs[] = {
 196         /* Huawei NCM devices disguised as vendor specific */
 197         { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x16),
 198           .driver_info = (unsigned long)&huawei_cdc_ncm_info,
 199         },
 200         { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x46),
 201           .driver_info = (unsigned long)&huawei_cdc_ncm_info,
 202         },
 203         { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x76),
 204           .driver_info = (unsigned long)&huawei_cdc_ncm_info,
 205         },
 206         { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x03, 0x16),
 207           .driver_info = (unsigned long)&huawei_cdc_ncm_info,
 208         },
 209
 210         /* Terminating entry */
 211         {
 212         },
 213 };
 214 MODULE_DEVICE_TABLE(usb, huawei_cdc_ncm_devs);
 215
 216 static struct usb_driver huawei_cdc_ncm_driver = {
 217         .name = "huawei_cdc_ncm",
 218         .id_table = huawei_cdc_ncm_devs,
 219         .probe = usbnet_probe,
 220         .disconnect = usbnet_disconnect,
 221         .suspend = huawei_cdc_ncm_suspend,
 222         .resume = huawei_cdc_ncm_resume,
 223         .reset_resume = huawei_cdc_ncm_resume,
 224         .supports_autosuspend = 1,
 225         .disable_hub_initiated_lpm = 1,
 226 };
 227 module_usb_driver(huawei_cdc_ncm_driver);
 228 MODULE_AUTHOR("Enrico Mioso <mrkiko.rs@gmail.com>");
 229 MODULE_DESCRIPTION("USB CDC NCM host driver with encapsulated protocol support");
 230 MODULE_LICENSE("GPL");