Commit c3ecb08a authored by Bjørn Mork's avatar Bjørn Mork Committed by Greg Kroah-Hartman
Browse files

net: qmi_wwan: support devices having a shared QMI/wwan interface 



Use the new cdc-wdm subdriver interface to create a device management
device even for USB devices having a single combined QMI/wwan USB
interface with three endpoints (int, bulk in, bulk out) instead of
separate data and control interfaces.

Some Huawei devices can be switched to a single interface mode for
use with other operating systems than Linux.  This adds support
for these devices when they run in such non-Linux modes.

Signed-off-by: default avatarBjørn Mork <bjorn@mork.no>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 423ce8ca

drivers/net/usb/qmi_wwan.c

+152 −16
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#include <linux/usb.h>

#include <linux/usb/cdc.h>

#include <linux/usb/usbnet.h>

#include <linux/usb/cdc-wdm.h>



/* The name of the CDC Device Management driver */

#define DM_DRIVER "cdc_wdm"
@@ -64,6 +65,9 @@ static int qmi_wwan_bind(struct usbnet *dev, struct usb_interface *intf) 
	struct usb_cdc_ether_desc *cdc_ether = NULL;

	u32 required = 1 << USB_CDC_HEADER_TYPE | 1 << USB_CDC_UNION_TYPE;

	u32 found = 0;

	atomic_t *pmcount = (void *)&dev->data[1];



	atomic_set(pmcount, 0);



	/*

	 * assume a data interface has no additional descriptors and
@@ -170,13 +174,127 @@ err: 
	return status;

}



/* stolen from cdc_ether.c */

/* 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)

{

	atomic_t *pmcount = (void *)&dev->data[1];

	int rv = 0;



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



	if ((on && atomic_add_return(1, pmcount) == 1) || (!on && atomic_dec_and_test(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;

	return 0;

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

	return qmi_wwan_manage_power(dev, on);

}



/* Some devices combine the "control" and "data" functions into a

 * single interface with all three endpoints: interrupt + bulk in and

 * out

 *

 * Setting up cdc-wdm as a subdriver owning the interrupt endpoint

 * will let it provide userspace access to the encapsulated QMI

 * protocol without interfering with the usbnet operations.

  */

static int qmi_wwan_bind_shared(struct usbnet *dev, struct usb_interface *intf)

{

	int rv;

	struct usb_driver *subdriver = NULL;

	atomic_t *pmcount = (void *)&dev->data[1];



	atomic_set(pmcount, 0);



	/* collect all three endpoints */

	rv = usbnet_get_endpoints(dev, intf);

	if (rv < 0)

		goto err;



	/* require interrupt endpoint for subdriver */

	if (!dev->status) {

		rv = -EINVAL;

		goto err;

	}



	subdriver = usb_cdc_wdm_register(intf, &dev->status->desc, 512, &qmi_wwan_cdc_wdm_manage_power);

	if (IS_ERR(subdriver)) {

		rv = PTR_ERR(subdriver);

		goto err;

	}



	/* can't let usbnet use the interrupt endpoint */

	dev->status = NULL;



	/* save subdriver struct for suspend/resume wrappers */

	dev->data[0] = (unsigned long)subdriver;



err:

	return rv;

}



static void qmi_wwan_unbind_shared(struct usbnet *dev, struct usb_interface *intf)

{

	struct usb_driver *subdriver = (void *)dev->data[0];



	if (subdriver && subdriver->disconnect)

		subdriver->disconnect(intf);



	dev->data[0] = (unsigned long)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 usb_driver *subdriver = (void *)dev->data[0];

	int ret;



	ret = usbnet_suspend(intf, message);

	if (ret < 0)

		goto err;



	if (subdriver && subdriver->suspend)

		ret = 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 usb_driver *subdriver = (void *)dev->data[0];

	int ret = 0;



	if (subdriver && subdriver->resume)

		ret = subdriver->resume(intf);

	if (ret < 0)

		goto err;

	ret = usbnet_resume(intf);

	if (ret < 0 && subdriver && subdriver->resume && subdriver->suspend)

		subdriver->suspend(intf, PMSG_SUSPEND);

err:

	return ret;

}





static const struct driver_info	qmi_wwan_info = {

	.description	= "QMI speaking wwan device",

	.flags		= FLAG_WWAN,
@@ -184,19 +302,37 @@ static const struct driver_info qmi_wwan_info = { 
	.manage_power	= qmi_wwan_manage_power,

};



static const struct driver_info	qmi_wwan_shared = {

	.description	= "QMI speaking wwan device with combined interface",

	.flags		= FLAG_WWAN,

	.bind		= qmi_wwan_bind_shared,

	.unbind		= qmi_wwan_unbind_shared,

	.manage_power	= qmi_wwan_manage_power,

};



#define HUAWEI_VENDOR_ID	0x12D1



static const struct usb_device_id products[] = {

{

	/* Huawei E392, E398 and possibly others sharing both device id and more... */

	{	/* Huawei E392, E398 and possibly others sharing both device id and more... */

		.match_flags        = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO,

		.idVendor           = HUAWEI_VENDOR_ID,

		.bInterfaceClass    = USB_CLASS_VENDOR_SPEC,

		.bInterfaceSubClass = 1,

		.bInterfaceProtocol = 8, /* NOTE: This is the *slave* interface of the CDC Union! */

		.driver_info        = (unsigned long)&qmi_wwan_info,

}, {

},	/* END */

	},

	{	/* Huawei E392, E398 and possibly others in "Windows mode"

		 * using a combined control and data interface without any CDC

		 * functional descriptors

		 */

		.match_flags        = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_INT_INFO,

		.idVendor           = HUAWEI_VENDOR_ID,

		.bInterfaceClass    = USB_CLASS_VENDOR_SPEC,

		.bInterfaceSubClass = 1,

		.bInterfaceProtocol = 17,

		.driver_info        = (unsigned long)&qmi_wwan_shared,

	},

	{ }	/* END */

};

MODULE_DEVICE_TABLE(usb, products);
@@ -205,9 +341,9 @@ static struct usb_driver qmi_wwan_driver = { 
	.id_table	      = products,

	.probe		      =	usbnet_probe,

	.disconnect	      = usbnet_disconnect,

	.suspend	      = usbnet_suspend,

	.resume		      =	usbnet_resume,

	.reset_resume         = usbnet_resume,

	.suspend	      = qmi_wwan_suspend,

	.resume		      =	qmi_wwan_resume,

	.reset_resume         = qmi_wwan_resume,

	.supports_autosuspend = 1,

};

CRA Git | Maintained and supported by SUSTech CRA and CCSE