[deliverable/linux.git] / drivers / net / usb / huawei_cdc_ncm.c

/* huawei_cdc_ncm.c - handles Huawei devices using the CDC NCM protocol as
 * transport layer.
 * Copyright (C) 2013	 Enrico Mioso <mrkiko.rs@gmail.com>
 *
 *
 * ABSTRACT:
 * This driver handles devices resembling the CDC NCM standard, but
 * encapsulating another protocol inside it. An example are some Huawei 3G
 * devices, exposing an embedded AT channel where you can set up the NCM
 * connection.
 * This code has been heavily inspired by the cdc_mbim.c driver, which is
 * Copyright (c) 2012  Smith Micro Software, Inc.
 * Copyright (c) 2012  Bjørn Mork <bjorn@mork.no>
 *
 * 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/if_vlan.h>
#include <linux/ip.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>
#include <linux/usb/cdc_ncm.h>

/* Driver data */
struct huawei_cdc_ncm_state {
	struct cdc_ncm_ctx *ctx;
	atomic_t pmcount;
	struct usb_driver *subdriver;
	struct usb_interface *control;
	struct usb_interface *data;
};

static int huawei_cdc_ncm_manage_power(struct usbnet *usbnet_dev, int on)
{
	struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
	int rv;

	if ((on && atomic_add_return(1, &drvstate->pmcount) == 1) ||
			(!on && atomic_dec_and_test(&drvstate->pmcount))) {
		rv = usb_autopm_get_interface(usbnet_dev->intf);
		usbnet_dev->intf->needs_remote_wakeup = on;
		if (!rv)
			usb_autopm_put_interface(usbnet_dev->intf);
	}
	return 0;
}

static int huawei_cdc_ncm_wdm_manage_power(struct usb_interface *intf,
					   int status)
{
	struct usbnet *usbnet_dev = usb_get_intfdata(intf);

	/* can be called while disconnecting */
	if (!usbnet_dev)
		return 0;

	return huawei_cdc_ncm_manage_power(usbnet_dev, status);
}


static int huawei_cdc_ncm_bind(struct usbnet *usbnet_dev,
			       struct usb_interface *intf)
{
	struct cdc_ncm_ctx *ctx;
	struct usb_driver *subdriver = ERR_PTR(-ENODEV);
	int ret = -ENODEV;
	struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;

	/* altsetting should always be 1 for NCM devices - so we hard-coded
	 * it here
	 */
	ret = cdc_ncm_bind_common(usbnet_dev, intf, 1);
	if (ret)
		goto err;

	ctx = drvstate->ctx;

	if (usbnet_dev->status)
		/* CDC-WMC r1.1 requires wMaxCommand to be "at least 256
		 * decimal (0x100)"
		 */
		subdriver = usb_cdc_wdm_register(ctx->control,
						 &usbnet_dev->status->desc,
						 256, /* wMaxCommand */
						 huawei_cdc_ncm_wdm_manage_power);
	if (IS_ERR(subdriver)) {
		ret = PTR_ERR(subdriver);
		cdc_ncm_unbind(usbnet_dev, intf);
		goto err;
	}

	/* Prevent usbnet from using the status descriptor */
	usbnet_dev->status = NULL;

	drvstate->subdriver = subdriver;

err:
	return ret;
}

static void huawei_cdc_ncm_unbind(struct usbnet *usbnet_dev,
				  struct usb_interface *intf)
{
	struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
	struct cdc_ncm_ctx *ctx = drvstate->ctx;

	if (drvstate->subdriver && drvstate->subdriver->disconnect)
		drvstate->subdriver->disconnect(ctx->control);
	drvstate->subdriver = NULL;

	cdc_ncm_unbind(usbnet_dev, intf);
}

static int huawei_cdc_ncm_suspend(struct usb_interface *intf,
				  pm_message_t message)
{
	int ret = 0;
	struct usbnet *usbnet_dev = usb_get_intfdata(intf);
	struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
	struct cdc_ncm_ctx *ctx = drvstate->ctx;

	if (ctx == NULL) {
		ret = -ENODEV;
		goto error;
	}

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

	if (intf == ctx->control &&
		drvstate->subdriver &&
		drvstate->subdriver->suspend)
		ret = drvstate->subdriver->suspend(intf, message);
	if (ret < 0)
		usbnet_resume(intf);

error:
	return ret;
}

static int huawei_cdc_ncm_resume(struct usb_interface *intf)
{
	int ret = 0;
	struct usbnet *usbnet_dev = usb_get_intfdata(intf);
	struct huawei_cdc_ncm_state *drvstate = (void *)&usbnet_dev->data;
	bool callsub;
	struct cdc_ncm_ctx *ctx = drvstate->ctx;

	/* should we call subdriver's resume function? */
	callsub =
		(intf == ctx->control &&
		drvstate->subdriver &&
		drvstate->subdriver->resume);

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

static int huawei_cdc_ncm_check_connect(struct usbnet *usbnet_dev)
{
	struct cdc_ncm_ctx *ctx;

	ctx = (struct cdc_ncm_ctx *)usbnet_dev->data[0];

	if (ctx == NULL)
		return 1; /* disconnected */

	return !ctx->connected;
}

static const struct driver_info huawei_cdc_ncm_info = {
	.description = "Huawei CDC NCM device",
	.flags = FLAG_NO_SETINT | FLAG_MULTI_PACKET | FLAG_WWAN,
	.bind = huawei_cdc_ncm_bind,
	.unbind = huawei_cdc_ncm_unbind,
	.check_connect = huawei_cdc_ncm_check_connect,
	.manage_power = huawei_cdc_ncm_manage_power,
	.rx_fixup = cdc_ncm_rx_fixup,
	.tx_fixup = cdc_ncm_tx_fixup,
};

static const struct usb_device_id huawei_cdc_ncm_devs[] = {
	/* Huawei NCM devices disguised as vendor specific */
	{ USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x16),
	  .driver_info = (unsigned long)&huawei_cdc_ncm_info,
	},
	{ USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x46),
	  .driver_info = (unsigned long)&huawei_cdc_ncm_info,
	},
	{ USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x76),
	  .driver_info = (unsigned long)&huawei_cdc_ncm_info,
	},

	/* Terminating entry */
	{
	},
};
MODULE_DEVICE_TABLE(usb, huawei_cdc_ncm_devs);

static struct usb_driver huawei_cdc_ncm_driver = {
	.name = "huawei_cdc_ncm",
	.id_table = huawei_cdc_ncm_devs,
	.probe = usbnet_probe,
	.disconnect = usbnet_disconnect,
	.suspend = huawei_cdc_ncm_suspend,
	.resume = huawei_cdc_ncm_resume,
	.reset_resume = huawei_cdc_ncm_resume,
	.supports_autosuspend = 1,
	.disable_hub_initiated_lpm = 1,
};
module_usb_driver(huawei_cdc_ncm_driver);
MODULE_AUTHOR("Enrico Mioso <mrkiko.rs@gmail.com>");
MODULE_DESCRIPTION("USB CDC NCM host driver with encapsulated protocol support");
MODULE_LICENSE("GPL");
Commit	Line	Data
41c47d8c EM	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
77	/* altsetting should always be 1 for NCM devices - so we hard-coded
78	* it here
79	*/
80	ret = cdc_ncm_bind_common(usbnet_dev, intf, 1);
81	if (ret)
82	goto err;
83
84	ctx = drvstate->ctx;
85
86	if (usbnet_dev->status)
87	/* CDC-WMC r1.1 requires wMaxCommand to be "at least 256
88	* decimal (0x100)"
89	*/
90	subdriver = usb_cdc_wdm_register(ctx->control,
91	&usbnet_dev->status->desc,
92	256, /* wMaxCommand */
93	huawei_cdc_ncm_wdm_manage_power);
94	if (IS_ERR(subdriver)) {
95	ret = PTR_ERR(subdriver);
96	cdc_ncm_unbind(usbnet_dev, intf);
97	goto err;
98	}
99
100	/* Prevent usbnet from using the status descriptor */
101	usbnet_dev->status = NULL;
102
103	drvstate->subdriver = subdriver;
104
105	err:
106	return ret;
107	}
108
109	static void huawei_cdc_ncm_unbind(struct usbnet *usbnet_dev,
110	struct usb_interface *intf)
111	{
112	struct huawei_cdc_ncm_state drvstate = (void )&usbnet_dev->data;
113	struct cdc_ncm_ctx *ctx = drvstate->ctx;
114
115	if (drvstate->subdriver && drvstate->subdriver->disconnect)
116	drvstate->subdriver->disconnect(ctx->control);
117	drvstate->subdriver = NULL;
118
119	cdc_ncm_unbind(usbnet_dev, intf);
120	}
121
122	static int huawei_cdc_ncm_suspend(struct usb_interface *intf,
123	pm_message_t message)
124	{
125	int ret = 0;
126	struct usbnet *usbnet_dev = usb_get_intfdata(intf);
127	struct huawei_cdc_ncm_state drvstate = (void )&usbnet_dev->data;
128	struct cdc_ncm_ctx *ctx = drvstate->ctx;
129
130	if (ctx == NULL) {
131	ret = -ENODEV;
132	goto error;
133	}
134
135	ret = usbnet_suspend(intf, message);
136	if (ret < 0)
137	goto error;
138
139	if (intf == ctx->control &&
140	drvstate->subdriver &&
141	drvstate->subdriver->suspend)
142	ret = drvstate->subdriver->suspend(intf, message);
143	if (ret < 0)
144	usbnet_resume(intf);
145
146	error:
147	return ret;
148	}
149
150	static int huawei_cdc_ncm_resume(struct usb_interface *intf)
151	{
152	int ret = 0;
153	struct usbnet *usbnet_dev = usb_get_intfdata(intf);
154	struct huawei_cdc_ncm_state drvstate = (void )&usbnet_dev->data;
155	bool callsub;
156	struct cdc_ncm_ctx *ctx = drvstate->ctx;
157
158	/* should we call subdriver's resume function? */
159	callsub =
160	(intf == ctx->control &&
161	drvstate->subdriver &&
162	drvstate->subdriver->resume);
163
164	if (callsub)
165	ret = drvstate->subdriver->resume(intf);
166	if (ret < 0)
167	goto err;
168	ret = usbnet_resume(intf);
169	if (ret < 0 && callsub)
170	drvstate->subdriver->suspend(intf, PMSG_SUSPEND);
171	err:
172	return ret;
173	}
174
175	static int huawei_cdc_ncm_check_connect(struct usbnet *usbnet_dev)
176	{
177	struct cdc_ncm_ctx *ctx;
178
179	ctx = (struct cdc_ncm_ctx *)usbnet_dev->data[0];
180
181	if (ctx == NULL)
182	return 1; /* disconnected */
183
184	return !ctx->connected;
185	}
186
187	static const struct driver_info huawei_cdc_ncm_info = {
188	.description = "Huawei CDC NCM device",
189	.flags = FLAG_NO_SETINT \| FLAG_MULTI_PACKET \| FLAG_WWAN,
190	.bind = huawei_cdc_ncm_bind,
191	.unbind = huawei_cdc_ncm_unbind,
192	.check_connect = huawei_cdc_ncm_check_connect,
193	.manage_power = huawei_cdc_ncm_manage_power,
194	.rx_fixup = cdc_ncm_rx_fixup,
195	.tx_fixup = cdc_ncm_tx_fixup,
196	};
197
198	static const struct usb_device_id huawei_cdc_ncm_devs[] = {
199	/* Huawei NCM devices disguised as vendor specific */
200	{ USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x16),
201	.driver_info = (unsigned long)&huawei_cdc_ncm_info,
202	},
203	{ USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x46),
204	.driver_info = (unsigned long)&huawei_cdc_ncm_info,
205	},
206	{ USB_VENDOR_AND_INTERFACE_INFO(0x12d1, 0xff, 0x02, 0x76),
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");