qmi_wwan_simcom.c

/*
 * Copyright (c) 2012  Bjørn Mork <[email protected]>
 *
 * The probing code is heavily inspired by cdc_ether, which is:
 * Copyright (C) 2003-2005 by David Brownell
 * Copyright (C) 2006 by Ole Andre Vadla Ravnas (ActiveSync)
 *
 * 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/etherdevice.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>

/* This driver supports wwan (3G/LTE/?) devices using a vendor
 * specific management protocol called Qualcomm MSM Interface (QMI) -
 * in addition to the more common AT commands over serial interface
 * management
 *
 * QMI is wrapped in CDC, using CDC encapsulated commands on the
 * control ("master") interface of a two-interface CDC Union
 * resembling standard CDC ECM.  The devices do not use the control
 * interface for any other CDC messages.  Most likely because the
 * management protocol is used in place of the standard CDC
 * notifications NOTIFY_NETWORK_CONNECTION and NOTIFY_SPEED_CHANGE
 *
 * Alternatively, control and data functions can be combined in a
 * single USB interface.
 *
 * Handling a protocol like QMI is out of the scope for any driver.
 * It is exported as a character device using the cdc-wdm driver as
 * a subdriver, enabling userspace applications ("modem managers") to
 * handle it.
 *
 * These devices may alternatively/additionally be configured using AT
 * commands on a serial interface
 */

/* driver specific data */
struct qmi_wwan_state {
    struct usb_driver *subdriver;
    atomic_t pmcount;
    unsigned long unused;
    struct usb_interface *control;
    struct usb_interface *data;
};

/* default ethernet address used by the modem */
static const u8 default_modem_addr[ETH_ALEN] = {0x02, 0x50, 0xf3};

/* Make up an ethernet header if the packet doesn't have one.
 *
 * A firmware bug common among several devices cause them to send raw
 * IP packets under some circumstances.  There is no way for the
 * driver/host to know when this will happen.  And even when the bug
 * hits, some packets will still arrive with an intact header.
 *
 * The supported devices are only capably of sending IPv4, IPv6 and
 * ARP packets on a point-to-point link. Any packet with an ethernet
 * header will have either our address or a broadcast/multicast
 * address as destination.  ARP packets will always have a header.
 *
 * This means that this function will reliably add the appropriate
 * header iff necessary, provided our hardware address does not start
 * with 4 or 6.
 *
 * Another common firmware bug results in all packets being addressed
 * to 00:a0:c6:00:00:00 despite the host address being different.
 * This function will also fixup such packets.
 */
static int qmi_wwan_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
{
    __be16 proto;

    /* This check is no longer done by usbnet */
    if (skb->len < dev->net->hard_header_len)
        return 0;

    switch (skb->data[0] & 0xf0) {
    case 0x40:
        proto = htons(ETH_P_IP);
        break;
    case 0x60:
        proto = htons(ETH_P_IPV6);
        break;
    case 0x00:
        if (is_multicast_ether_addr(skb->data))
            return 1;
        /* possibly bogus destination - rewrite just in case */
        skb_reset_mac_header(skb);
        goto fix_dest;
    default:
        /* pass along other packets without modifications */
        return 1;
    }
    if (skb_headroom(skb) < ETH_HLEN)
        return 0;
    skb_push(skb, ETH_HLEN);
    skb_reset_mac_header(skb);
    eth_hdr(skb)->h_proto = proto;
    memset(eth_hdr(skb)->h_source, 0, ETH_ALEN);
fix_dest:
    memcpy(eth_hdr(skb)->h_dest, dev->net->dev_addr, ETH_ALEN);
    return 1;
}

struct sk_buff *qmi_wwan_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
{
    if (dev->udev->descriptor.idVendor != cpu_to_le16(0x1e0e))
        return skb;
    //skip ethernet header
    if (skb_pull(skb, ETH_HLEN))
    {
        return skb;
    }
    else
    {
        dev_err(&dev->intf->dev, "Packet Dropped\n");
    }

    if (skb != NULL)
        dev_kfree_skb_any(skb);

    return NULL;
}

/* very simplistic detection of IPv4 or IPv6 headers */
static bool possibly_iphdr(const char *data)
{
    return (data[0] & 0xd0) == 0x40;
}

/* disallow addresses which may be confused with IP headers */
static int qmi_wwan_mac_addr(struct net_device *dev, void *p)
{
    int ret;
    struct sockaddr *addr = p;

    ret = eth_prepare_mac_addr_change(dev, p);
    if (ret < 0)
        return ret;
    if (possibly_iphdr(addr->sa_data))
        return -EADDRNOTAVAIL;
    eth_commit_mac_addr_change(dev, p);
    return 0;
}

static const struct net_device_ops qmi_wwan_netdev_ops = {
    .ndo_open       = usbnet_open,
    .ndo_stop       = usbnet_stop,
    .ndo_start_xmit     = usbnet_start_xmit,
    .ndo_tx_timeout     = usbnet_tx_timeout,
    .ndo_change_mtu     = usbnet_change_mtu,
    .ndo_set_mac_address    = qmi_wwan_mac_addr,
    .ndo_validate_addr  = eth_validate_addr,
};

/* using a counter to merge subdriver requests with our own into a
 * combined state
 */
static int qmi_wwan_manage_power(struct usbnet *dev, int on)
{
    struct qmi_wwan_state *info = (void *)&dev->data;
    int rv;

    dev_dbg(&dev->intf->dev, "%s() pmcount=%d, on=%d\n", __func__,
        atomic_read(&info->pmcount), on);

    if ((on && atomic_add_return(1, &info->pmcount) == 1) ||
        (!on && atomic_dec_and_test(&info->pmcount))) {
        /* need autopm_get/put here to ensure the usbcore sees
         * the new value
         */
        rv = usb_autopm_get_interface(dev->intf);
        dev->intf->needs_remote_wakeup = on;
        if (!rv)
            usb_autopm_put_interface(dev->intf);
    }
    return 0;
}

static int qmi_wwan_cdc_wdm_manage_power(struct usb_interface *intf, int on)
{
    struct usbnet *dev = usb_get_intfdata(intf);

    /* can be called while disconnecting */
    if (!dev)
        return 0;
    return qmi_wwan_manage_power(dev, on);
}

/* collect all three endpoints and register subdriver */
static int qmi_wwan_register_subdriver(struct usbnet *dev)
{
    int rv;
    struct usb_driver *subdriver = NULL;
    struct qmi_wwan_state *info = (void *)&dev->data;

    /* collect bulk endpoints */
    rv = usbnet_get_endpoints(dev, info->data);
    if (rv < 0)
        goto err;

    /* update status endpoint if separate control interface */
    if (info->control != info->data)
        dev->status = &info->control->cur_altsetting->endpoint[0];

    /* require interrupt endpoint for subdriver */
    if (!dev->status) {
        rv = -EINVAL;
        goto err;
    }

    /* for subdriver power management */
    atomic_set(&info->pmcount, 0);

    /* register subdriver */
    subdriver = usb_cdc_wdm_register(info->control, &dev->status->desc,
                     4096, &qmi_wwan_cdc_wdm_manage_power);
    if (IS_ERR(subdriver)) {
        dev_err(&info->control->dev, "subdriver registration failed\n");
        rv = PTR_ERR(subdriver);
        goto err;
    }

    /* prevent usbnet from using status endpoint */
    dev->status = NULL;

    /* save subdriver struct for suspend/resume wrappers */
    info->subdriver = subdriver;

err:
    return rv;
}

static int qmi_wwan_bind(struct usbnet *dev, struct usb_interface *intf)
{
    int status = -1;
    u8 *buf = intf->cur_altsetting->extra;
    int len = intf->cur_altsetting->extralen;
    struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc;
    struct usb_cdc_union_desc *cdc_union = NULL;
    struct usb_cdc_ether_desc *cdc_ether = NULL;
    u32 found = 0;
    struct usb_driver *driver = driver_of(intf);
    struct qmi_wwan_state *info = (void *)&dev->data;

    BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data) <
              sizeof(struct qmi_wwan_state)));

    /* set up initial state */
    info->control = intf;
    info->data = intf;

    /* and a number of CDC descriptors */
    while (len > 3) {
        struct usb_descriptor_header *h = (void *)buf;

        /* ignore any misplaced descriptors */
        if (h->bDescriptorType != USB_DT_CS_INTERFACE)
            goto next_desc;

        /* buf[2] is CDC descriptor subtype */
        switch (buf[2]) {
        case USB_CDC_HEADER_TYPE:
            if (found & 1 << USB_CDC_HEADER_TYPE) {
                dev_dbg(&intf->dev, "extra CDC header\n");
                goto err;
            }
            if (h->bLength != sizeof(struct usb_cdc_header_desc)) {
                dev_dbg(&intf->dev, "CDC header len %u\n",
                    h->bLength);
                goto err;
            }
            break;
        case USB_CDC_UNION_TYPE:
            if (found & 1 << USB_CDC_UNION_TYPE) {
                dev_dbg(&intf->dev, "extra CDC union\n");
                goto err;
            }
            if (h->bLength != sizeof(struct usb_cdc_union_desc)) {
                dev_dbg(&intf->dev, "CDC union len %u\n",
                    h->bLength);
                goto err;
            }
            cdc_union = (struct usb_cdc_union_desc *)buf;
            break;
        case USB_CDC_ETHERNET_TYPE:
            if (found & 1 << USB_CDC_ETHERNET_TYPE) {
                dev_dbg(&intf->dev, "extra CDC ether\n");
                goto err;
            }
            if (h->bLength != sizeof(struct usb_cdc_ether_desc)) {
                dev_dbg(&intf->dev, "CDC ether len %u\n",
                    h->bLength);
                goto err;
            }
            cdc_ether = (struct usb_cdc_ether_desc *)buf;
            break;
        }

        /* Remember which CDC functional descriptors we've seen.  Works
         * for all types we care about, of which USB_CDC_ETHERNET_TYPE
         * (0x0f) is the highest numbered
         */
        if (buf[2] < 32)
            found |= 1 << buf[2];

next_desc:
        len -= h->bLength;
        buf += h->bLength;
    }

    /* Use separate control and data interfaces if we found a CDC Union */
    if (cdc_union) {
        info->data = usb_ifnum_to_if(dev->udev,
                         cdc_union->bSlaveInterface0);
        if (desc->bInterfaceNumber != cdc_union->bMasterInterface0 ||
            !info->data) {
            dev_err(&intf->dev,
                "bogus CDC Union: master=%u, slave=%u\n",
                cdc_union->bMasterInterface0,
                cdc_union->bSlaveInterface0);
            goto err;
        }
    }

    /* errors aren't fatal - we can live with the dynamic address */
    if (cdc_ether && cdc_ether->wMaxSegmentSize) {
        dev->hard_mtu = le16_to_cpu(cdc_ether->wMaxSegmentSize);
        usbnet_get_ethernet_addr(dev, cdc_ether->iMACAddress);
    }

    /* claim data interface and set it up */
    if (info->control != info->data) {
        status = usb_driver_claim_interface(driver, info->data, dev);
        if (status < 0)
            goto err;
    }

    status = qmi_wwan_register_subdriver(dev);
    if (status < 0 && info->control != info->data) {
        usb_set_intfdata(info->data, NULL);
        usb_driver_release_interface(driver, info->data);
    }

    /* Never use the same address on both ends of the link, even
     * if the buggy firmware told us to.
     */
    if (ether_addr_equal(dev->net->dev_addr, default_modem_addr))
        eth_hw_addr_random(dev->net);

    /* make MAC addr easily distinguishable from an IP header */
    if (possibly_iphdr(dev->net->dev_addr)) {
        dev->net->dev_addr[0] |= 0x02;  /* set local assignment bit */
        dev->net->dev_addr[0] &= 0xbf;  /* clear "IP" bit */
    }
    dev->net->netdev_ops = &qmi_wwan_netdev_ops;

#if 1 //Added by Simcom
    if (dev->udev->descriptor.idVendor == cpu_to_le16(0x1e0e)) {
        dev_info(&intf->dev, "SIMCom 8200 work on RawIP mode\n");
        dev->net->flags |= IFF_NOARP;
        usb_control_msg(
            interface_to_usbdev(intf),
            usb_sndctrlpipe(interface_to_usbdev(intf), 0),
            0x22, //USB_CDC_REQ_SET_CONTROL_LINE_STATE
            0x21, //USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE
            1, //active CDC DTR
            intf->cur_altsetting->desc.bInterfaceNumber,
            NULL,
            0,
            100
            );
    }
#endif

err:
    return status;
}

static void qmi_wwan_unbind(struct usbnet *dev, struct usb_interface *intf)
{
    struct qmi_wwan_state *info = (void *)&dev->data;
    struct usb_driver *driver = driver_of(intf);
    struct usb_interface *other;

    if (info->subdriver && info->subdriver->disconnect)
        info->subdriver->disconnect(info->control);

    /* allow user to unbind using either control or data */
    if (intf == info->control)
        other = info->data;
    else
        other = info->control;

    /* only if not shared */
    if (other && intf != other) {
        usb_set_intfdata(other, NULL);
        usb_driver_release_interface(driver, other);
    }

    info->subdriver = NULL;
    info->data = NULL;
    info->control = NULL;
}

/* suspend/resume wrappers calling both usbnet and the cdc-wdm
 * subdriver if present.
 *
 * NOTE: cdc-wdm also supports pre/post_reset, but we cannot provide
 * wrappers for those without adding usbnet reset support first.
 */
static int qmi_wwan_suspend(struct usb_interface *intf, pm_message_t message)
{
    struct usbnet *dev = usb_get_intfdata(intf);
    struct qmi_wwan_state *info = (void *)&dev->data;
    int ret;

    /* Both usbnet_suspend() and subdriver->suspend() MUST return 0
     * in system sleep context, otherwise, the resume callback has
     * to recover device from previous suspend failure.
     */
    ret = usbnet_suspend(intf, message);
    if (ret < 0)
        goto err;

    if (intf == info->control && info->subdriver &&
        info->subdriver->suspend)
        ret = info->subdriver->suspend(intf, message);
    if (ret < 0)
        usbnet_resume(intf);
err:
    return ret;
}

static int qmi_wwan_resume(struct usb_interface *intf)
{
    struct usbnet *dev = usb_get_intfdata(intf);
    struct qmi_wwan_state *info = (void *)&dev->data;
    int ret = 0;
    bool callsub = (intf == info->control && info->subdriver &&
            info->subdriver->resume);

    if (callsub)
        ret = info->subdriver->resume(intf);
    if (ret < 0)
        goto err;
    ret = usbnet_resume(intf);
    if (ret < 0 && callsub)
        info->subdriver->suspend(intf, PMSG_SUSPEND);
err:
    return ret;
}

static const struct driver_info qmi_wwan_info = {
    .description    = "WWAN/QMI device",
    .flags      = FLAG_WWAN,
    .bind       = qmi_wwan_bind,
    .unbind     = qmi_wwan_unbind,
    .manage_power   = qmi_wwan_manage_power,
    .rx_fixup       = qmi_wwan_rx_fixup,
};

static const struct driver_info qmi_wwan_raw_ip_info = {
    .description    = "WWAN/QMI device",
    .flags      = FLAG_WWAN,
    .bind       = qmi_wwan_bind,
    .unbind     = qmi_wwan_unbind,
    .manage_power   = qmi_wwan_manage_power,
    .rx_fixup       = qmi_wwan_rx_fixup,
    .tx_fixup       = qmi_wwan_tx_fixup,
};

#define HUAWEI_VENDOR_ID    0x12D1

/* map QMI/wwan function by a fixed interface number */
#define QMI_FIXED_INTF(vend, prod, num) \
    USB_DEVICE_INTERFACE_NUMBER(vend, prod, num), \
    .driver_info = (unsigned long)&qmi_wwan_info

#define QMI_FIXED_RAWIP_INTF(vend, prod, num) \
    USB_DEVICE_INTERFACE_NUMBER(vend, prod, num), \
    .driver_info = (unsigned long)&qmi_wwan_raw_ip_info

/* Gobi 1000 QMI/wwan interface number is 3 according to qcserial */
#define QMI_GOBI1K_DEVICE(vend, prod) \
    QMI_FIXED_INTF(vend, prod, 3)

/* Gobi 2000/3000 QMI/wwan interface number is 0 according to qcserial */
#define QMI_GOBI_DEVICE(vend, prod) \
    QMI_FIXED_INTF(vend, prod, 0)

static const struct usb_device_id products[] = {
    {QMI_FIXED_RAWIP_INTF(0x1e0e, 0x9001, 5)},  /* SIMCOM 8200 */
    { }                 /* END */
};
MODULE_DEVICE_TABLE(usb, products);

static bool quectel_ec20_detected(struct usb_interface *intf)
{
    struct usb_device *dev = interface_to_usbdev(intf);

    if (dev->actconfig &&
        le16_to_cpu(dev->descriptor.idVendor) == 0x05c6 &&
        le16_to_cpu(dev->descriptor.idProduct) == 0x9215 &&
        dev->actconfig->desc.bNumInterfaces == 5)
        return true;

    return false;
}

static int qmi_wwan_probe(struct usb_interface *intf,
              const struct usb_device_id *prod)
{
    struct usb_device_id *id = (struct usb_device_id *)prod;
    struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc;

    /* Workaround to enable dynamic IDs.  This disables usbnet
     * blacklisting functionality.  Which, if required, can be
     * reimplemented here by using a magic "blacklist" value
     * instead of 0 in the static device id table
     */
    if (!id->driver_info) {
        dev_dbg(&intf->dev, "setting defaults for dynamic device id\n");
        id->driver_info = (unsigned long)&qmi_wwan_info;
    }

    /* There are devices where the same interface number can be
     * configured as different functions. We should only bind to
     * vendor specific functions when matching on interface number
     */
    if (id->match_flags & USB_DEVICE_ID_MATCH_INT_NUMBER &&
        desc->bInterfaceClass != USB_CLASS_VENDOR_SPEC) {
        dev_dbg(&intf->dev,
            "Rejecting interface number match for class %02x\n",
            desc->bInterfaceClass);
        return -ENODEV;
    }

    /* Quectel EC20 quirk where we've QMI on interface 4 instead of 0 */
    if (quectel_ec20_detected(intf) && desc->bInterfaceNumber == 0) {
        dev_dbg(&intf->dev, "Quectel EC20 quirk, skipping interface 0\n");
        return -ENODEV;
    }

    return usbnet_probe(intf, id);
}

static struct usb_driver qmi_wwan_driver = {
    .name             = "qmi_wwan_simcom",
    .id_table         = products,
    .probe            = qmi_wwan_probe,
    .disconnect       = usbnet_disconnect,
    .suspend          = qmi_wwan_suspend,
    .resume           = qmi_wwan_resume,
    .reset_resume         = qmi_wwan_resume,
    .supports_autosuspend = 1,
    .disable_hub_initiated_lpm = 1,
};

module_usb_driver(qmi_wwan_driver);

MODULE_AUTHOR("Bjørn Mork <[email protected]>");
MODULE_DESCRIPTION("Qualcomm MSM Interface (QMI) WWAN driver");
MODULE_LICENSE("GPL");
MODULE_VERSION("Simcom_Linux_QMI_WWAN_Driver_V1.0");