[linux-2.6-block.git] / drivers / net / usb / qmi_wwan.c

/*
 * Copyright (c) 2012  Bjørn Mork <bjorn@mork.no>
 *
 * 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/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;
};

/* 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 = 0;

	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);
		if (rv < 0)
			goto err;
		dev->intf->needs_remote_wakeup = on;
		usb_autopm_put_interface(dev->intf);
	}
err:
	return rv;
}

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, 512, &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)));

	/* require a single interrupt status endpoint for subdriver */
	if (intf->cur_altsetting->desc.bNumEndpoints != 1)
		goto err;

	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;
	}

	/* did we find all the required ones? */
	if (!(found & (1 << USB_CDC_HEADER_TYPE)) ||
	    !(found & (1 << USB_CDC_UNION_TYPE))) {
		dev_err(&intf->dev, "CDC functional descriptors missing\n");
		goto err;
	}

	/* verify CDC Union */
	if (desc->bInterfaceNumber != cdc_union->bMasterInterface0) {
		dev_err(&intf->dev, "bogus CDC Union: master=%u\n", cdc_union->bMasterInterface0);
		goto err;
	}

	/* need to save these for unbind */
	info->control = intf;
	info->data = usb_ifnum_to_if(dev->udev,	cdc_union->bSlaveInterface0);
	if (!info->data) {
		dev_err(&intf->dev, "bogus CDC Union: slave=%u\n", cdc_union->bSlaveInterface0);
		goto err;
	}

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

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

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

err:
	return status;
}

/* Some devices combine the "control" and "data" functions into a
 * single interface with all three endpoints: interrupt + bulk in and
 * out
 */
static int qmi_wwan_bind_shared(struct usbnet *dev, struct usb_interface *intf)
{
	struct qmi_wwan_state *info = (void *)&dev->data;

	/*  control and data is shared */
	info->control = intf;
	info->data = intf;
	return qmi_wwan_register_subdriver(dev);
}

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;

	ret = usbnet_suspend(intf, message);
	if (ret < 0)
		goto err;

	if (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;

	if (info->subdriver && info->subdriver->resume)
		ret = info->subdriver->resume(intf);
	if (ret < 0)
		goto err;
	ret = usbnet_resume(intf);
	if (ret < 0 && info->subdriver && info->subdriver->resume && info->subdriver->suspend)
		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,
};

static const struct driver_info	qmi_wwan_shared = {
	.description	= "WWAN/QMI device",
	.flags		= FLAG_WWAN,
	.bind		= qmi_wwan_bind_shared,
	.unbind		= qmi_wwan_unbind,
	.manage_power	= qmi_wwan_manage_power,
};

#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_shared

/* 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[] = {
	/* 1. CDC ECM like devices match on the control interface */
	{	/* Huawei E392, E398 and possibly others sharing both device id and more... */
		USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 9),
		.driver_info        = (unsigned long)&qmi_wwan_info,
	},
	{	/* Vodafone/Huawei K5005 (12d1:14c8) and similar modems */
		USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 57),
		.driver_info        = (unsigned long)&qmi_wwan_info,
	},

	/* 2. Combined interface devices matching on class+protocol */
	{	/* Huawei E392, E398 and possibly others in "Windows mode" */
		USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 17),
		.driver_info        = (unsigned long)&qmi_wwan_shared,
	},
	{	/* Pantech UML290 */
		USB_DEVICE_AND_INTERFACE_INFO(0x106c, 0x3718, USB_CLASS_VENDOR_SPEC, 0xf0, 0xff),
		.driver_info        = (unsigned long)&qmi_wwan_shared,
	},
	{	/* Pantech UML290 - newer firmware */
		USB_DEVICE_AND_INTERFACE_INFO(0x106c, 0x3718, USB_CLASS_VENDOR_SPEC, 0xf1, 0xff),
		.driver_info        = (unsigned long)&qmi_wwan_shared,
	},

	/* 3. Combined interface devices matching on interface number */
	{QMI_FIXED_INTF(0x19d2, 0x0055, 1)},	/* ZTE (Vodafone) K3520-Z */
	{QMI_FIXED_INTF(0x19d2, 0x0063, 4)},	/* ZTE (Vodafone) K3565-Z */
	{QMI_FIXED_INTF(0x19d2, 0x0104, 4)},	/* ZTE (Vodafone) K4505-Z */
	{QMI_FIXED_INTF(0x19d2, 0x0167, 4)},	/* ZTE MF820D */
	{QMI_FIXED_INTF(0x19d2, 0x0326, 4)},	/* ZTE MF821D */
	{QMI_FIXED_INTF(0x19d2, 0x1008, 4)},	/* ZTE (Vodafone) K3570-Z */
	{QMI_FIXED_INTF(0x19d2, 0x1010, 4)},	/* ZTE (Vodafone) K3571-Z */
	{QMI_FIXED_INTF(0x19d2, 0x1018, 3)},	/* ZTE (Vodafone) K5006-Z */
	{QMI_FIXED_INTF(0x19d2, 0x1402, 2)},	/* ZTE MF60 */
	{QMI_FIXED_INTF(0x19d2, 0x2002, 4)},	/* ZTE (Vodafone) K3765-Z */
	{QMI_FIXED_INTF(0x0f3d, 0x68a2, 8)},    /* Sierra Wireless MC7700 */
	{QMI_FIXED_INTF(0x114f, 0x68a2, 8)},    /* Sierra Wireless MC7750 */
	{QMI_FIXED_INTF(0x1199, 0x68a2, 8)},	/* Sierra Wireless MC7710 in QMI mode */
	{QMI_FIXED_INTF(0x1199, 0x68a2, 19)},	/* Sierra Wireless MC7710 in QMI mode */
	{QMI_FIXED_INTF(0x1199, 0x901c, 8)},    /* Sierra Wireless EM7700 */

	/* 4. Gobi 1000 devices */
	{QMI_GOBI1K_DEVICE(0x05c6, 0x9212)},	/* Acer Gobi Modem Device */
	{QMI_GOBI1K_DEVICE(0x03f0, 0x1f1d)},	/* HP un2400 Gobi Modem Device */
	{QMI_GOBI1K_DEVICE(0x04da, 0x250d)},	/* Panasonic Gobi Modem device */
	{QMI_GOBI1K_DEVICE(0x413c, 0x8172)},	/* Dell Gobi Modem device */
	{QMI_GOBI1K_DEVICE(0x1410, 0xa001)},	/* Novatel Gobi Modem device */
	{QMI_GOBI1K_DEVICE(0x0b05, 0x1776)},	/* Asus Gobi Modem device */
	{QMI_GOBI1K_DEVICE(0x19d2, 0xfff3)},	/* ONDA Gobi Modem device */
	{QMI_GOBI1K_DEVICE(0x05c6, 0x9001)},	/* Generic Gobi Modem device */
	{QMI_GOBI1K_DEVICE(0x05c6, 0x9002)},	/* Generic Gobi Modem device */
	{QMI_GOBI1K_DEVICE(0x05c6, 0x9202)},	/* Generic Gobi Modem device */
	{QMI_GOBI1K_DEVICE(0x05c6, 0x9203)},	/* Generic Gobi Modem device */
	{QMI_GOBI1K_DEVICE(0x05c6, 0x9222)},	/* Generic Gobi Modem device */
	{QMI_GOBI1K_DEVICE(0x05c6, 0x9009)},	/* Generic Gobi Modem device */

	/* 5. Gobi 2000 and 3000 devices */
	{QMI_GOBI_DEVICE(0x413c, 0x8186)},	/* Dell Gobi 2000 Modem device (N0218, VU936) */
	{QMI_GOBI_DEVICE(0x413c, 0x8194)},	/* Dell Gobi 3000 Composite */
	{QMI_GOBI_DEVICE(0x05c6, 0x920b)},	/* Generic Gobi 2000 Modem device */
	{QMI_GOBI_DEVICE(0x05c6, 0x920d)},	/* Gobi 3000 Composite */
	{QMI_GOBI_DEVICE(0x05c6, 0x9225)},	/* Sony Gobi 2000 Modem device (N0279, VU730) */
	{QMI_GOBI_DEVICE(0x05c6, 0x9245)},	/* Samsung Gobi 2000 Modem device (VL176) */
	{QMI_GOBI_DEVICE(0x03f0, 0x251d)},	/* HP Gobi 2000 Modem device (VP412) */
	{QMI_GOBI_DEVICE(0x05c6, 0x9215)},	/* Acer Gobi 2000 Modem device (VP413) */
	{QMI_GOBI_DEVICE(0x05c6, 0x9265)},	/* Asus Gobi 2000 Modem device (VR305) */
	{QMI_GOBI_DEVICE(0x05c6, 0x9235)},	/* Top Global Gobi 2000 Modem device (VR306) */
	{QMI_GOBI_DEVICE(0x05c6, 0x9275)},	/* iRex Technologies Gobi 2000 Modem device (VR307) */
	{QMI_GOBI_DEVICE(0x1199, 0x68a5)},	/* Sierra Wireless Modem */
	{QMI_GOBI_DEVICE(0x1199, 0x68a9)},	/* Sierra Wireless Modem */
	{QMI_GOBI_DEVICE(0x1199, 0x9001)},	/* Sierra Wireless Gobi 2000 Modem device (VT773) */
	{QMI_GOBI_DEVICE(0x1199, 0x9002)},	/* Sierra Wireless Gobi 2000 Modem device (VT773) */
	{QMI_GOBI_DEVICE(0x1199, 0x9003)},	/* Sierra Wireless Gobi 2000 Modem device (VT773) */
	{QMI_GOBI_DEVICE(0x1199, 0x9004)},	/* Sierra Wireless Gobi 2000 Modem device (VT773) */
	{QMI_GOBI_DEVICE(0x1199, 0x9005)},	/* Sierra Wireless Gobi 2000 Modem device (VT773) */
	{QMI_GOBI_DEVICE(0x1199, 0x9006)},	/* Sierra Wireless Gobi 2000 Modem device (VT773) */
	{QMI_GOBI_DEVICE(0x1199, 0x9007)},	/* Sierra Wireless Gobi 2000 Modem device (VT773) */
	{QMI_GOBI_DEVICE(0x1199, 0x9008)},	/* Sierra Wireless Gobi 2000 Modem device (VT773) */
	{QMI_GOBI_DEVICE(0x1199, 0x9009)},	/* Sierra Wireless Gobi 2000 Modem device (VT773) */
	{QMI_GOBI_DEVICE(0x1199, 0x900a)},	/* Sierra Wireless Gobi 2000 Modem device (VT773) */
	{QMI_GOBI_DEVICE(0x1199, 0x9011)},	/* Sierra Wireless Gobi 2000 Modem device (MC8305) */
	{QMI_FIXED_INTF(0x1199, 0x9011, 5)},	/* alternate interface number!? */
	{QMI_GOBI_DEVICE(0x16d8, 0x8002)},	/* CMDTech Gobi 2000 Modem device (VU922) */
	{QMI_GOBI_DEVICE(0x05c6, 0x9205)},	/* Gobi 2000 Modem device */
	{QMI_GOBI_DEVICE(0x1199, 0x9013)},	/* Sierra Wireless Gobi 3000 Modem device (MC8355) */
	{QMI_GOBI_DEVICE(0x03f0, 0x371d)},	/* HP un2430 Mobile Broadband Module */
	{QMI_GOBI_DEVICE(0x1199, 0x9015)},	/* Sierra Wireless Gobi 3000 Modem device */
	{QMI_GOBI_DEVICE(0x1199, 0x9019)},	/* Sierra Wireless Gobi 3000 Modem device */
	{QMI_GOBI_DEVICE(0x1199, 0x901b)},	/* Sierra Wireless MC7770 */
	{QMI_GOBI_DEVICE(0x12d1, 0x14f1)},	/* Sony Gobi 3000 Composite */
	{QMI_GOBI_DEVICE(0x1410, 0xa021)},	/* Foxconn Gobi 3000 Modem device (Novatel E396) */

	{ }					/* END */
};
MODULE_DEVICE_TABLE(usb, products);

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;

	/* 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_shared;
	}

	return usbnet_probe(intf, id);
}

static struct usb_driver qmi_wwan_driver = {
	.name		      = "qmi_wwan",
	.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 <bjorn@mork.no>");
MODULE_DESCRIPTION("Qualcomm MSM Interface (QMI) WWAN driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
423ce8ca BM	1	/*
	2	* Copyright (c) 2012 Bjørn Mork <bjorn@mork.no>
	3	*
230718bd BM	4	* The probing code is heavily inspired by cdc_ether, which is:
	5	* Copyright (C) 2003-2005 by David Brownell
	6	* Copyright (C) 2006 by Ole Andre Vadla Ravnas (ActiveSync)
	7	*
423ce8ca BM	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License
	10	* version 2 as published by the Free Software Foundation.
	11	*/
	12
	13	#include <linux/module.h>
	14	#include <linux/netdevice.h>
	15	#include <linux/ethtool.h>
	16	#include <linux/mii.h>
	17	#include <linux/usb.h>
	18	#include <linux/usb/cdc.h>
	19	#include <linux/usb/usbnet.h>
c3ecb08a	20	#include <linux/usb/cdc-wdm.h>
423ce8ca	21
230718bd	22	/* This driver supports wwan (3G/LTE/?) devices using a vendor
423ce8ca BM	23	* specific management protocol called Qualcomm MSM Interface (QMI) -
	24	* in addition to the more common AT commands over serial interface
	25	* management
	26	*
	27	* QMI is wrapped in CDC, using CDC encapsulated commands on the
	28	* control ("master") interface of a two-interface CDC Union
	29	* resembling standard CDC ECM. The devices do not use the control
	30	* interface for any other CDC messages. Most likely because the
	31	* management protocol is used in place of the standard CDC
	32	* notifications NOTIFY_NETWORK_CONNECTION and NOTIFY_SPEED_CHANGE
	33	*
230718bd BM	34	* Alternatively, control and data functions can be combined in a
	35	* single USB interface.
	36	*
423ce8ca	37	* Handling a protocol like QMI is out of the scope for any driver.
230718bd BM	38	* It is exported as a character device using the cdc-wdm driver as
	39	* a subdriver, enabling userspace applications ("modem managers") to
	40	* handle it.
423ce8ca BM	41	*
423ce8ca BM	42	* These devices may alternatively/additionally be configured using AT
230718bd	43	* commands on a serial interface
423ce8ca BM	44	*/
423ce8ca BM	45
853c24f7 BM	46	/* driver specific data */
	47	struct qmi_wwan_state {
	48	struct usb_driver *subdriver;
	49	atomic_t pmcount;
f47cd136 BM	50	unsigned long unused;
	51	struct usb_interface *control;
	52	struct usb_interface *data;
853c24f7 BM	53	};
853c24f7 BM	54
f47cd136 BM	55	/* using a counter to merge subdriver requests with our own into a combined state */
	56	static int qmi_wwan_manage_power(struct usbnet *dev, int on)
	57	{
	58	struct qmi_wwan_state info = (void )&dev->data;
	59	int rv = 0;
	60
	61	dev_dbg(&dev->intf->dev, "%s() pmcount=%d, on=%d\n", __func__, atomic_read(&info->pmcount), on);
	62
	63	if ((on && atomic_add_return(1, &info->pmcount) == 1) \|\| (!on && atomic_dec_and_test(&info->pmcount))) {
	64	/* need autopm_get/put here to ensure the usbcore sees the new value */
	65	rv = usb_autopm_get_interface(dev->intf);
	66	if (rv < 0)
	67	goto err;
	68	dev->intf->needs_remote_wakeup = on;
	69	usb_autopm_put_interface(dev->intf);
	70	}
	71	err:
	72	return rv;
	73	}
	74
	75	static int qmi_wwan_cdc_wdm_manage_power(struct usb_interface *intf, int on)
	76	{
	77	struct usbnet *dev = usb_get_intfdata(intf);
b26d344c DM	78
	79	/* can be called while disconnecting */
	80	if (!dev)
	81	return 0;
f47cd136 BM	82	return qmi_wwan_manage_power(dev, on);
	83	}
	84
	85	/* collect all three endpoints and register subdriver */
	86	static int qmi_wwan_register_subdriver(struct usbnet *dev)
	87	{
	88	int rv;
	89	struct usb_driver *subdriver = NULL;
	90	struct qmi_wwan_state info = (void )&dev->data;
	91
	92	/* collect bulk endpoints */
	93	rv = usbnet_get_endpoints(dev, info->data);
	94	if (rv < 0)
	95	goto err;
	96
	97	/* update status endpoint if separate control interface */
	98	if (info->control != info->data)
	99	dev->status = &info->control->cur_altsetting->endpoint[0];
	100
	101	/* require interrupt endpoint for subdriver */
	102	if (!dev->status) {
	103	rv = -EINVAL;
	104	goto err;
	105	}
	106
	107	/* for subdriver power management */
	108	atomic_set(&info->pmcount, 0);
	109
	110	/* register subdriver */
	111	subdriver = usb_cdc_wdm_register(info->control, &dev->status->desc, 512, &qmi_wwan_cdc_wdm_manage_power);
	112	if (IS_ERR(subdriver)) {
	113	dev_err(&info->control->dev, "subdriver registration failed\n");
	114	rv = PTR_ERR(subdriver);
	115	goto err;
	116	}
	117
	118	/* prevent usbnet from using status endpoint */
	119	dev->status = NULL;
	120
	121	/* save subdriver struct for suspend/resume wrappers */
	122	info->subdriver = subdriver;
	123
	124	err:
	125	return rv;
	126	}
	127
423ce8ca BM	128	static int qmi_wwan_bind(struct usbnet dev, struct usb_interface intf)
	129	{
	130	int status = -1;
423ce8ca BM	131	u8 *buf = intf->cur_altsetting->extra;
	132	int len = intf->cur_altsetting->extralen;
	133	struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc;
	134	struct usb_cdc_union_desc *cdc_union = NULL;
	135	struct usb_cdc_ether_desc *cdc_ether = NULL;
423ce8ca	136	u32 found = 0;
230718bd	137	struct usb_driver *driver = driver_of(intf);
853c24f7 BM	138	struct qmi_wwan_state info = (void )&dev->data;
	139
	140	BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data) < sizeof(struct qmi_wwan_state)));
c3ecb08a	141
230718bd BM	142	/* require a single interrupt status endpoint for subdriver */
	143	if (intf->cur_altsetting->desc.bNumEndpoints != 1)
	144	goto err;
423ce8ca BM	145
	146	while (len > 3) {
	147	struct usb_descriptor_header h = (void )buf;
	148
	149	/* ignore any misplaced descriptors */
	150	if (h->bDescriptorType != USB_DT_CS_INTERFACE)
	151	goto next_desc;
	152
	153	/* buf[2] is CDC descriptor subtype */
	154	switch (buf[2]) {
	155	case USB_CDC_HEADER_TYPE:
	156	if (found & 1 << USB_CDC_HEADER_TYPE) {
	157	dev_dbg(&intf->dev, "extra CDC header\n");
	158	goto err;
	159	}
	160	if (h->bLength != sizeof(struct usb_cdc_header_desc)) {
	161	dev_dbg(&intf->dev, "CDC header len %u\n", h->bLength);
	162	goto err;
	163	}
	164	break;
	165	case USB_CDC_UNION_TYPE:
	166	if (found & 1 << USB_CDC_UNION_TYPE) {
	167	dev_dbg(&intf->dev, "extra CDC union\n");
	168	goto err;
	169	}
	170	if (h->bLength != sizeof(struct usb_cdc_union_desc)) {
	171	dev_dbg(&intf->dev, "CDC union len %u\n", h->bLength);
	172	goto err;
	173	}
	174	cdc_union = (struct usb_cdc_union_desc *)buf;
	175	break;
	176	case USB_CDC_ETHERNET_TYPE:
	177	if (found & 1 << USB_CDC_ETHERNET_TYPE) {
	178	dev_dbg(&intf->dev, "extra CDC ether\n");
	179	goto err;
	180	}
	181	if (h->bLength != sizeof(struct usb_cdc_ether_desc)) {
	182	dev_dbg(&intf->dev, "CDC ether len %u\n", h->bLength);
	183	goto err;
	184	}
	185	cdc_ether = (struct usb_cdc_ether_desc *)buf;
	186	break;
	187	}
	188
	189	/*
	190	* Remember which CDC functional descriptors we've seen. Works
	191	* for all types we care about, of which USB_CDC_ETHERNET_TYPE
	192	* (0x0f) is the highest numbered
	193	*/
	194	if (buf[2] < 32)
	195	found \|= 1 << buf[2];
	196
	197	next_desc:
	198	len -= h->bLength;
	199	buf += h->bLength;
	200	}
	201
	202	/* did we find all the required ones? */
5ac24979 DC	203	if (!(found & (1 << USB_CDC_HEADER_TYPE)) \|\|
5ac24979 DC	204	!(found & (1 << USB_CDC_UNION_TYPE))) {
423ce8ca BM	205	dev_err(&intf->dev, "CDC functional descriptors missing\n");
	206	goto err;
	207	}
	208
230718bd BM	209	/* verify CDC Union */
	210	if (desc->bInterfaceNumber != cdc_union->bMasterInterface0) {
	211	dev_err(&intf->dev, "bogus CDC Union: master=%u\n", cdc_union->bMasterInterface0);
	212	goto err;
	213	}
	214
	215	/* need to save these for unbind */
	216	info->control = intf;
	217	info->data = usb_ifnum_to_if(dev->udev, cdc_union->bSlaveInterface0);
	218	if (!info->data) {
	219	dev_err(&intf->dev, "bogus CDC Union: slave=%u\n", cdc_union->bSlaveInterface0);
423ce8ca BM	220	goto err;
	221	}
	222
	223	/* errors aren't fatal - we can live with the dynamic address */
	224	if (cdc_ether) {
	225	dev->hard_mtu = le16_to_cpu(cdc_ether->wMaxSegmentSize);
	226	usbnet_get_ethernet_addr(dev, cdc_ether->iMACAddress);
	227	}
	228
230718bd BM	229	/* claim data interface and set it up */
	230	status = usb_driver_claim_interface(driver, info->data, dev);
	231	if (status < 0)
	232	goto err;
423ce8ca	233
230718bd BM	234	status = qmi_wwan_register_subdriver(dev);
	235	if (status < 0) {
	236	usb_set_intfdata(info->data, NULL);
	237	usb_driver_release_interface(driver, info->data);
	238	}
423ce8ca BM	239
	240	err:
	241	return status;
	242	}
	243
c3ecb08a BM	244	/* Some devices combine the "control" and "data" functions into a
	245	* single interface with all three endpoints: interrupt + bulk in and
	246	* out
230718bd	247	*/
c3ecb08a BM	248	static int qmi_wwan_bind_shared(struct usbnet dev, struct usb_interface intf)
c3ecb08a BM	249	{
853c24f7	250	struct qmi_wwan_state info = (void )&dev->data;
c3ecb08a	251
f47cd136 BM	252	/* control and data is shared */
	253	info->control = intf;
	254	info->data = intf;
03304bcb	255	return qmi_wwan_register_subdriver(dev);
c3ecb08a BM	256	}
c3ecb08a BM	257
230718bd	258	static void qmi_wwan_unbind(struct usbnet dev, struct usb_interface intf)
c3ecb08a	259	{
853c24f7	260	struct qmi_wwan_state info = (void )&dev->data;
230718bd BM	261	struct usb_driver *driver = driver_of(intf);
230718bd BM	262	struct usb_interface *other;
c3ecb08a	263
853c24f7	264	if (info->subdriver && info->subdriver->disconnect)
230718bd BM	265	info->subdriver->disconnect(info->control);
	266
	267	/* allow user to unbind using either control or data */
	268	if (intf == info->control)
	269	other = info->data;
	270	else
	271	other = info->control;
	272
	273	/* only if not shared */
	274	if (other && intf != other) {
	275	usb_set_intfdata(other, NULL);
	276	usb_driver_release_interface(driver, other);
	277	}
c3ecb08a	278
853c24f7	279	info->subdriver = NULL;
230718bd BM	280	info->data = NULL;
230718bd BM	281	info->control = NULL;
c3ecb08a BM	282	}
	283
	284	/* suspend/resume wrappers calling both usbnet and the cdc-wdm
	285	* subdriver if present.
	286	*
	287	* NOTE: cdc-wdm also supports pre/post_reset, but we cannot provide
	288	* wrappers for those without adding usbnet reset support first.
	289	*/
	290	static int qmi_wwan_suspend(struct usb_interface *intf, pm_message_t message)
	291	{
	292	struct usbnet *dev = usb_get_intfdata(intf);
853c24f7	293	struct qmi_wwan_state info = (void )&dev->data;
c3ecb08a BM	294	int ret;
	295
	296	ret = usbnet_suspend(intf, message);
	297	if (ret < 0)
	298	goto err;
	299
853c24f7 BM	300	if (info->subdriver && info->subdriver->suspend)
853c24f7 BM	301	ret = info->subdriver->suspend(intf, message);
c3ecb08a BM	302	if (ret < 0)
	303	usbnet_resume(intf);
	304	err:
	305	return ret;
	306	}
	307
	308	static int qmi_wwan_resume(struct usb_interface *intf)
	309	{
	310	struct usbnet *dev = usb_get_intfdata(intf);
853c24f7	311	struct qmi_wwan_state info = (void )&dev->data;
c3ecb08a BM	312	int ret = 0;
c3ecb08a BM	313
853c24f7 BM	314	if (info->subdriver && info->subdriver->resume)
853c24f7 BM	315	ret = info->subdriver->resume(intf);
c3ecb08a BM	316	if (ret < 0)
	317	goto err;
	318	ret = usbnet_resume(intf);
853c24f7 BM	319	if (ret < 0 && info->subdriver && info->subdriver->resume && info->subdriver->suspend)
853c24f7 BM	320	info->subdriver->suspend(intf, PMSG_SUSPEND);
c3ecb08a BM	321	err:
	322	return ret;
	323	}
	324
423ce8ca	325	static const struct driver_info qmi_wwan_info = {
a40345b5	326	.description = "WWAN/QMI device",
423ce8ca BM	327	.flags = FLAG_WWAN,
423ce8ca BM	328	.bind = qmi_wwan_bind,
230718bd	329	.unbind = qmi_wwan_unbind,
423ce8ca BM	330	.manage_power = qmi_wwan_manage_power,
	331	};
	332
c3ecb08a	333	static const struct driver_info qmi_wwan_shared = {
a40345b5	334	.description = "WWAN/QMI device",
c3ecb08a BM	335	.flags = FLAG_WWAN,
c3ecb08a BM	336	.bind = qmi_wwan_bind_shared,
230718bd	337	.unbind = qmi_wwan_unbind,
c3ecb08a BM	338	.manage_power = qmi_wwan_manage_power,
	339	};
	340
423ce8ca	341	#define HUAWEI_VENDOR_ID 0x12D1
b9f90eb2	342
03304bcb BM	343	/* map QMI/wwan function by a fixed interface number */
	344	#define QMI_FIXED_INTF(vend, prod, num) \
	345	USB_DEVICE_INTERFACE_NUMBER(vend, prod, num), \
	346	.driver_info = (unsigned long)&qmi_wwan_shared
	347
b9f90eb2 BM	348	/* Gobi 1000 QMI/wwan interface number is 3 according to qcserial */
b9f90eb2 BM	349	#define QMI_GOBI1K_DEVICE(vend, prod) \
03304bcb	350	QMI_FIXED_INTF(vend, prod, 3)
b9f90eb2	351
03304bcb	352	/* Gobi 2000/3000 QMI/wwan interface number is 0 according to qcserial */
b086cf04	353	#define QMI_GOBI_DEVICE(vend, prod) \
03304bcb	354	QMI_FIXED_INTF(vend, prod, 0)
423ce8ca BM	355
423ce8ca BM	356	static const struct usb_device_id products[] = {
03304bcb	357	/* 1. CDC ECM like devices match on the control interface */
c3ecb08a	358	{ /* Huawei E392, E398 and possibly others sharing both device id and more... */
5ea42963	359	USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 9),
c3ecb08a BM	360	.driver_info = (unsigned long)&qmi_wwan_info,
c3ecb08a BM	361	},
88c16dc3	362	{ /* Vodafone/Huawei K5005 (12d1:14c8) and similar modems */
5ea42963	363	USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 57),
88c16dc3 BM	364	.driver_info = (unsigned long)&qmi_wwan_info,
88c16dc3 BM	365	},
03304bcb BM	366
	367	/* 2. Combined interface devices matching on class+protocol */
	368	{ /* Huawei E392, E398 and possibly others in "Windows mode" */
5ea42963	369	USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, USB_CLASS_VENDOR_SPEC, 1, 17),
c3ecb08a BM	370	.driver_info = (unsigned long)&qmi_wwan_shared,
c3ecb08a BM	371	},
b086cf04	372	{ /* Pantech UML290 */
5ea42963	373	USB_DEVICE_AND_INTERFACE_INFO(0x106c, 0x3718, USB_CLASS_VENDOR_SPEC, 0xf0, 0xff),
b086cf04 BM	374	.driver_info = (unsigned long)&qmi_wwan_shared,
b086cf04 BM	375	},
10cbc1d9 BM	376	{ /* Pantech UML290 - newer firmware */
	377	USB_DEVICE_AND_INTERFACE_INFO(0x106c, 0x3718, USB_CLASS_VENDOR_SPEC, 0xf1, 0xff),
	378	.driver_info = (unsigned long)&qmi_wwan_shared,
	379	},
b9f90eb2	380
03304bcb BM	381	/* 3. Combined interface devices matching on interface number */
	382	{QMI_FIXED_INTF(0x19d2, 0x0055, 1)}, /* ZTE (Vodafone) K3520-Z */
	383	{QMI_FIXED_INTF(0x19d2, 0x0063, 4)}, /* ZTE (Vodafone) K3565-Z */
	384	{QMI_FIXED_INTF(0x19d2, 0x0104, 4)}, /* ZTE (Vodafone) K4505-Z */
	385	{QMI_FIXED_INTF(0x19d2, 0x0167, 4)}, /* ZTE MF820D */
	386	{QMI_FIXED_INTF(0x19d2, 0x0326, 4)}, /* ZTE MF821D */
	387	{QMI_FIXED_INTF(0x19d2, 0x1008, 4)}, /* ZTE (Vodafone) K3570-Z */
	388	{QMI_FIXED_INTF(0x19d2, 0x1010, 4)}, /* ZTE (Vodafone) K3571-Z */
10cbc1d9	389	{QMI_FIXED_INTF(0x19d2, 0x1018, 3)}, /* ZTE (Vodafone) K5006-Z */
03304bcb BM	390	{QMI_FIXED_INTF(0x19d2, 0x1402, 2)}, /* ZTE MF60 */
03304bcb BM	391	{QMI_FIXED_INTF(0x19d2, 0x2002, 4)}, /* ZTE (Vodafone) K3765-Z */
9b469a60 BM	392	{QMI_FIXED_INTF(0x0f3d, 0x68a2, 8)}, /* Sierra Wireless MC7700 */
9b469a60 BM	393	{QMI_FIXED_INTF(0x114f, 0x68a2, 8)}, /* Sierra Wireless MC7750 */
03304bcb BM	394	{QMI_FIXED_INTF(0x1199, 0x68a2, 8)}, /* Sierra Wireless MC7710 in QMI mode */
03304bcb BM	395	{QMI_FIXED_INTF(0x1199, 0x68a2, 19)}, /* Sierra Wireless MC7710 in QMI mode */
9b469a60	396	{QMI_FIXED_INTF(0x1199, 0x901c, 8)}, /* Sierra Wireless EM7700 */
03304bcb BM	397
03304bcb BM	398	/* 4. Gobi 1000 devices */
b9f90eb2 BM	399	{QMI_GOBI1K_DEVICE(0x05c6, 0x9212)}, /* Acer Gobi Modem Device */
b9f90eb2 BM	400	{QMI_GOBI1K_DEVICE(0x03f0, 0x1f1d)}, /* HP un2400 Gobi Modem Device */
b9f90eb2 BM	401	{QMI_GOBI1K_DEVICE(0x04da, 0x250d)}, /* Panasonic Gobi Modem device */
	402	{QMI_GOBI1K_DEVICE(0x413c, 0x8172)}, /* Dell Gobi Modem device */
	403	{QMI_GOBI1K_DEVICE(0x1410, 0xa001)}, /* Novatel Gobi Modem device */
	404	{QMI_GOBI1K_DEVICE(0x0b05, 0x1776)}, /* Asus Gobi Modem device */
	405	{QMI_GOBI1K_DEVICE(0x19d2, 0xfff3)}, /* ONDA Gobi Modem device */
	406	{QMI_GOBI1K_DEVICE(0x05c6, 0x9001)}, /* Generic Gobi Modem device */
	407	{QMI_GOBI1K_DEVICE(0x05c6, 0x9002)}, /* Generic Gobi Modem device */
	408	{QMI_GOBI1K_DEVICE(0x05c6, 0x9202)}, /* Generic Gobi Modem device */
	409	{QMI_GOBI1K_DEVICE(0x05c6, 0x9203)}, /* Generic Gobi Modem device */
	410	{QMI_GOBI1K_DEVICE(0x05c6, 0x9222)}, /* Generic Gobi Modem device */
	411	{QMI_GOBI1K_DEVICE(0x05c6, 0x9009)}, /* Generic Gobi Modem device */
	412
03304bcb	413	/* 5. Gobi 2000 and 3000 devices */
b086cf04	414	{QMI_GOBI_DEVICE(0x413c, 0x8186)}, /* Dell Gobi 2000 Modem device (N0218, VU936) */
50022005	415	{QMI_GOBI_DEVICE(0x413c, 0x8194)}, /* Dell Gobi 3000 Composite */
b086cf04	416	{QMI_GOBI_DEVICE(0x05c6, 0x920b)}, /* Generic Gobi 2000 Modem device */
50022005	417	{QMI_GOBI_DEVICE(0x05c6, 0x920d)}, /* Gobi 3000 Composite */
b086cf04 BM	418	{QMI_GOBI_DEVICE(0x05c6, 0x9225)}, /* Sony Gobi 2000 Modem device (N0279, VU730) */
	419	{QMI_GOBI_DEVICE(0x05c6, 0x9245)}, /* Samsung Gobi 2000 Modem device (VL176) */
	420	{QMI_GOBI_DEVICE(0x03f0, 0x251d)}, /* HP Gobi 2000 Modem device (VP412) */
	421	{QMI_GOBI_DEVICE(0x05c6, 0x9215)}, /* Acer Gobi 2000 Modem device (VP413) */
	422	{QMI_GOBI_DEVICE(0x05c6, 0x9265)}, /* Asus Gobi 2000 Modem device (VR305) */
	423	{QMI_GOBI_DEVICE(0x05c6, 0x9235)}, /* Top Global Gobi 2000 Modem device (VR306) */
	424	{QMI_GOBI_DEVICE(0x05c6, 0x9275)}, /* iRex Technologies Gobi 2000 Modem device (VR307) */
9b469a60 BM	425	{QMI_GOBI_DEVICE(0x1199, 0x68a5)}, /* Sierra Wireless Modem */
9b469a60 BM	426	{QMI_GOBI_DEVICE(0x1199, 0x68a9)}, /* Sierra Wireless Modem */
b086cf04 BM	427	{QMI_GOBI_DEVICE(0x1199, 0x9001)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */
	428	{QMI_GOBI_DEVICE(0x1199, 0x9002)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */
	429	{QMI_GOBI_DEVICE(0x1199, 0x9003)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */
	430	{QMI_GOBI_DEVICE(0x1199, 0x9004)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */
	431	{QMI_GOBI_DEVICE(0x1199, 0x9005)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */
	432	{QMI_GOBI_DEVICE(0x1199, 0x9006)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */
	433	{QMI_GOBI_DEVICE(0x1199, 0x9007)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */
	434	{QMI_GOBI_DEVICE(0x1199, 0x9008)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */
	435	{QMI_GOBI_DEVICE(0x1199, 0x9009)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */
	436	{QMI_GOBI_DEVICE(0x1199, 0x900a)}, /* Sierra Wireless Gobi 2000 Modem device (VT773) */
	437	{QMI_GOBI_DEVICE(0x1199, 0x9011)}, /* Sierra Wireless Gobi 2000 Modem device (MC8305) */
9b469a60	438	{QMI_FIXED_INTF(0x1199, 0x9011, 5)}, /* alternate interface number!? */
b086cf04 BM	439	{QMI_GOBI_DEVICE(0x16d8, 0x8002)}, /* CMDTech Gobi 2000 Modem device (VU922) */
	440	{QMI_GOBI_DEVICE(0x05c6, 0x9205)}, /* Gobi 2000 Modem device */
	441	{QMI_GOBI_DEVICE(0x1199, 0x9013)}, /* Sierra Wireless Gobi 3000 Modem device (MC8355) */
b48d6f8b	442	{QMI_GOBI_DEVICE(0x03f0, 0x371d)}, /* HP un2430 Mobile Broadband Module */
5e071b5d BM	443	{QMI_GOBI_DEVICE(0x1199, 0x9015)}, /* Sierra Wireless Gobi 3000 Modem device */
5e071b5d BM	444	{QMI_GOBI_DEVICE(0x1199, 0x9019)}, /* Sierra Wireless Gobi 3000 Modem device */
9b469a60	445	{QMI_GOBI_DEVICE(0x1199, 0x901b)}, /* Sierra Wireless MC7770 */
50022005	446	{QMI_GOBI_DEVICE(0x12d1, 0x14f1)}, /* Sony Gobi 3000 Composite */
fa026e22	447	{QMI_GOBI_DEVICE(0x1410, 0xa021)}, /* Foxconn Gobi 3000 Modem device (Novatel E396) */
9b469a60	448
b086cf04	449	{ } /* END */
423ce8ca BM	450	};
	451	MODULE_DEVICE_TABLE(usb, products);
	452
1817e83d BM	453	static int qmi_wwan_probe(struct usb_interface intf, const struct usb_device_id prod)
	454	{
	455	struct usb_device_id id = (struct usb_device_id )prod;
	456
	457	/* Workaround to enable dynamic IDs. This disables usbnet
	458	* blacklisting functionality. Which, if required, can be
	459	* reimplemented here by using a magic "blacklist" value
	460	* instead of 0 in the static device id table
	461	*/
	462	if (!id->driver_info) {
	463	dev_dbg(&intf->dev, "setting defaults for dynamic device id\n");
	464	id->driver_info = (unsigned long)&qmi_wwan_shared;
	465	}
	466
	467	return usbnet_probe(intf, id);
	468	}
	469
423ce8ca BM	470	static struct usb_driver qmi_wwan_driver = {
	471	.name = "qmi_wwan",
	472	.id_table = products,
1817e83d	473	.probe = qmi_wwan_probe,
423ce8ca	474	.disconnect = usbnet_disconnect,
c3ecb08a BM	475	.suspend = qmi_wwan_suspend,
	476	.resume = qmi_wwan_resume,
	477	.reset_resume = qmi_wwan_resume,
423ce8ca	478	.supports_autosuspend = 1,
e1f12eb6	479	.disable_hub_initiated_lpm = 1,
423ce8ca BM	480	};
423ce8ca BM	481
677a3d60	482	module_usb_driver(qmi_wwan_driver);
423ce8ca BM	483
	484	MODULE_AUTHOR("Bjørn Mork <bjorn@mork.no>");
	485	MODULE_DESCRIPTION("Qualcomm MSM Interface (QMI) WWAN driver");
	486	MODULE_LICENSE("GPL");