[linux-2.6-block.git] / drivers / net / wimax / i2400m / usb-notif.c

/*
 * Intel Wireless WiMAX Connection 2400m over USB
 * Notification handling
 *
 *
 * Copyright (C) 2007-2008 Intel Corporation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *   * Neither the name of Intel Corporation nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Intel Corporation <linux-wimax@intel.com>
 * Yanir Lubetkin <yanirx.lubetkin@intel.com>
 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
 *  - Initial implementation
 *
 *
 * The notification endpoint is active when the device is not in boot
 * mode; in here we just read and get notifications; based on those,
 * we act to either reinitialize the device after a reboot or to
 * submit a RX request.
 *
 * ROADMAP
 *
 * i2400mu_usb_notification_setup()
 *
 * i2400mu_usb_notification_release()
 *
 * i2400mu_usb_notification_cb()	Called when a URB is ready
 *   i2400mu_notif_grok()
 *     i2400m_dev_reset_handle()
 *     i2400mu_rx_kick()
 */
#include <linux/usb.h>
#include "i2400m-usb.h"


#define D_SUBMODULE notif
#include "usb-debug-levels.h"


static const
__le32 i2400m_ZERO_BARKER[4] = { 0, 0, 0, 0 };


/*
 * Process a received notification
 *
 * In normal operation mode, we can only receive two types of payloads
 * on the notification endpoint:
 *
 *   - a reboot barker, we do a bootstrap (the device has reseted).
 *
 *   - a block of zeroes: there is pending data in the IN endpoint
 */
static
int i2400mu_notification_grok(struct i2400mu *i2400mu, const void *buf,
				 size_t buf_len)
{
	int ret;
	struct device *dev = &i2400mu->usb_iface->dev;
	struct i2400m *i2400m = &i2400mu->i2400m;

	d_fnstart(4, dev, "(i2400m %p buf %p buf_len %zu)\n",
		  i2400mu, buf, buf_len);
	ret = -EIO;
	if (buf_len < sizeof(i2400m_NBOOT_BARKER))
		/* Not a bug, just ignore */
		goto error_bad_size;
	if (!memcmp(i2400m_NBOOT_BARKER, buf, sizeof(i2400m_NBOOT_BARKER))
	    || !memcmp(i2400m_SBOOT_BARKER, buf, sizeof(i2400m_SBOOT_BARKER)))
		ret = i2400m_dev_reset_handle(i2400m);
	else if (!memcmp(i2400m_ZERO_BARKER, buf, sizeof(i2400m_ZERO_BARKER))) {
		i2400mu_rx_kick(i2400mu);
		ret = 0;
	} else {	/* Unknown or unexpected data in the notif message */
		char prefix[64];
		ret = -EIO;
		dev_err(dev, "HW BUG? Unknown/unexpected data in notification "
			"message (%zu bytes)\n", buf_len);
		snprintf(prefix, sizeof(prefix), "%s %s: ",
			 dev_driver_string(dev), dev_name(dev));
		if (buf_len > 64) {
			print_hex_dump(KERN_ERR, prefix, DUMP_PREFIX_OFFSET,
				       8, 4, buf, 64, 0);
			printk(KERN_ERR "%s... (only first 64 bytes "
			       "dumped)\n", prefix);
		} else
			print_hex_dump(KERN_ERR, prefix, DUMP_PREFIX_OFFSET,
				       8, 4, buf, buf_len, 0);
	}
error_bad_size:
	d_fnend(4, dev, "(i2400m %p buf %p buf_len %zu) = %d\n",
		i2400mu, buf, buf_len, ret);
	return ret;
}


/*
 * URB callback for the notification endpoint
 *
 * @urb: the urb received from the notification endpoint
 *
 * This function will just process the USB side of the transaction,
 * checking everything is fine, pass the processing to
 * i2400m_notification_grok() and resubmit the URB.
 */
static
void i2400mu_notification_cb(struct urb *urb)
{
	int ret;
	struct i2400mu *i2400mu = urb->context;
	struct device *dev = &i2400mu->usb_iface->dev;

	d_fnstart(4, dev, "(urb %p status %d actual_length %d)\n",
		  urb, urb->status, urb->actual_length);
	ret = urb->status;
	switch (ret) {
	case 0:
		ret = i2400mu_notification_grok(i2400mu, urb->transfer_buffer,
						urb->actual_length);
		if (ret == -EIO && edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS,
					   EDC_ERROR_TIMEFRAME))
			goto error_exceeded;
		if (ret == -ENOMEM)	/* uff...power cycle? shutdown? */
			goto error_exceeded;
		break;
	case -EINVAL:			/* while removing driver */
	case -ENODEV:			/* dev disconnect ... */
	case -ENOENT:			/* ditto */
	case -ESHUTDOWN:		/* URB killed */
	case -ECONNRESET:		/* disconnection */
		goto out;		/* Notify around */
	default:			/* Some error? */
		if (edc_inc(&i2400mu->urb_edc,
			    EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME))
			goto error_exceeded;
		dev_err(dev, "notification: URB error %d, retrying\n",
			urb->status);
	}
	usb_mark_last_busy(i2400mu->usb_dev);
	ret = usb_submit_urb(i2400mu->notif_urb, GFP_ATOMIC);
	switch (ret) {
	case 0:
	case -EINVAL:			/* while removing driver */
	case -ENODEV:			/* dev disconnect ... */
	case -ENOENT:			/* ditto */
	case -ESHUTDOWN:		/* URB killed */
	case -ECONNRESET:		/* disconnection */
		break;			/* just ignore */
	default:			/* Some error? */
		dev_err(dev, "notification: cannot submit URB: %d\n", ret);
		goto error_submit;
	}
	d_fnend(4, dev, "(urb %p status %d actual_length %d) = void\n",
		urb, urb->status, urb->actual_length);
	return;

error_exceeded:
	dev_err(dev, "maximum errors in notification URB exceeded; "
		"resetting device\n");
error_submit:
	usb_queue_reset_device(i2400mu->usb_iface);
out:
	d_fnend(4, dev, "(urb %p status %d actual_length %d) = void\n",
		urb, urb->status, urb->actual_length);
	return;
}


/*
 * setup the notification endpoint
 *
 * @i2400m: device descriptor
 *
 * This procedure prepares the notification urb and handler for receiving
 * unsolicited barkers from the device.
 */
int i2400mu_notification_setup(struct i2400mu *i2400mu)
{
	struct device *dev = &i2400mu->usb_iface->dev;
	int usb_pipe, ret = 0;
	struct usb_endpoint_descriptor *epd;
	char *buf;

	d_fnstart(4, dev, "(i2400m %p)\n", i2400mu);
	buf = kmalloc(I2400MU_MAX_NOTIFICATION_LEN, GFP_KERNEL | GFP_DMA);
	if (buf == NULL) {
		dev_err(dev, "notification: buffer allocation failed\n");
		ret = -ENOMEM;
		goto error_buf_alloc;
	}

	i2400mu->notif_urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!i2400mu->notif_urb) {
		ret = -ENOMEM;
		dev_err(dev, "notification: cannot allocate URB\n");
		goto error_alloc_urb;
	}
	epd = usb_get_epd(i2400mu->usb_iface, I2400MU_EP_NOTIFICATION);
	usb_pipe = usb_rcvintpipe(i2400mu->usb_dev, epd->bEndpointAddress);
	usb_fill_int_urb(i2400mu->notif_urb, i2400mu->usb_dev, usb_pipe,
			 buf, I2400MU_MAX_NOTIFICATION_LEN,
			 i2400mu_notification_cb, i2400mu, epd->bInterval);
	ret = usb_submit_urb(i2400mu->notif_urb, GFP_KERNEL);
	if (ret != 0) {
		dev_err(dev, "notification: cannot submit URB: %d\n", ret);
		goto error_submit;
	}
	d_fnend(4, dev, "(i2400m %p) = %d\n", i2400mu, ret);
	return ret;

error_submit:
	usb_free_urb(i2400mu->notif_urb);
error_alloc_urb:
	kfree(buf);
error_buf_alloc:
	d_fnend(4, dev, "(i2400m %p) = %d\n", i2400mu, ret);
	return ret;
}


/*
 * Tear down of the notification mechanism
 *
 * @i2400m: device descriptor
 *
 * Kill the interrupt endpoint urb, free any allocated resources.
 *
 * We need to check if we have done it before as for example,
 * _suspend() call this; if after a suspend() we get a _disconnect()
 * (as the case is when hibernating), nothing bad happens.
 */
void i2400mu_notification_release(struct i2400mu *i2400mu)
{
	struct device *dev = &i2400mu->usb_iface->dev;

	d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu);
	if (i2400mu->notif_urb != NULL) {
		usb_kill_urb(i2400mu->notif_urb);
		kfree(i2400mu->notif_urb->transfer_buffer);
		usb_free_urb(i2400mu->notif_urb);
		i2400mu->notif_urb = NULL;
	}
	d_fnend(4, dev, "(i2400mu %p)\n", i2400mu);
}
Commit	Line	Data
a8ebf98f IPG	1	/*
	2	* Intel Wireless WiMAX Connection 2400m over USB
	3	* Notification handling
	4	*
	5	*
	6	* Copyright (C) 2007-2008 Intel Corporation. All rights reserved.
	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions
	10	* are met:
	11	*
	12	* * Redistributions of source code must retain the above copyright
	13	* notice, this list of conditions and the following disclaimer.
	14	* * Redistributions in binary form must reproduce the above copyright
	15	* notice, this list of conditions and the following disclaimer in
	16	* the documentation and/or other materials provided with the
	17	* distribution.
	18	* * Neither the name of Intel Corporation nor the names of its
	19	* contributors may be used to endorse or promote products derived
	20	* from this software without specific prior written permission.
	21	*
	22	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	23	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	24	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	25	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	26	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	27	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	28	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	29	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	30	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	31	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	32	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	33	*
	34	*
	35	* Intel Corporation <linux-wimax@intel.com>
	36	* Yanir Lubetkin <yanirx.lubetkin@intel.com>
	37	* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
	38	* - Initial implementation
	39	*
	40	*
	41	* The notification endpoint is active when the device is not in boot
	42	* mode; in here we just read and get notifications; based on those,
	43	* we act to either reinitialize the device after a reboot or to
	44	* submit a RX request.
	45	*
	46	* ROADMAP
	47	*
	48	* i2400mu_usb_notification_setup()
	49	*
	50	* i2400mu_usb_notification_release()
	51	*
	52	* i2400mu_usb_notification_cb() Called when a URB is ready
	53	* i2400mu_notif_grok()
	54	* i2400m_dev_reset_handle()
	55	* i2400mu_rx_kick()
	56	*/
	57	#include <linux/usb.h>
	58	#include "i2400m-usb.h"
	59
	60
	61	#define D_SUBMODULE notif
	62	#include "usb-debug-levels.h"
	63
	64
65	static const
66	__le32 i2400m_ZERO_BARKER[4] = { 0, 0, 0, 0 };
67
68
69	/*
70	* Process a received notification
71	*
72	* In normal operation mode, we can only receive two types of payloads
73	* on the notification endpoint:
74	*
75	* - a reboot barker, we do a bootstrap (the device has reseted).
76	*
77	* - a block of zeroes: there is pending data in the IN endpoint
78	*/
79	static
80	int i2400mu_notification_grok(struct i2400mu i2400mu, const void buf,
81	size_t buf_len)
82	{
83	int ret;
84	struct device *dev = &i2400mu->usb_iface->dev;
85	struct i2400m *i2400m = &i2400mu->i2400m;
86
87	d_fnstart(4, dev, "(i2400m %p buf %p buf_len %zu)\n",
88	i2400mu, buf, buf_len);
89	ret = -EIO;
90	if (buf_len < sizeof(i2400m_NBOOT_BARKER))
91	/* Not a bug, just ignore */
92	goto error_bad_size;
93	if (!memcmp(i2400m_NBOOT_BARKER, buf, sizeof(i2400m_NBOOT_BARKER))
94	\|\| !memcmp(i2400m_SBOOT_BARKER, buf, sizeof(i2400m_SBOOT_BARKER)))
95	ret = i2400m_dev_reset_handle(i2400m);
96	else if (!memcmp(i2400m_ZERO_BARKER, buf, sizeof(i2400m_ZERO_BARKER))) {
97	i2400mu_rx_kick(i2400mu);
98	ret = 0;
99	} else { /* Unknown or unexpected data in the notif message */
100	char prefix[64];
101	ret = -EIO;
102	dev_err(dev, "HW BUG? Unknown/unexpected data in notification "
103	"message (%zu bytes)\n", buf_len);
104	snprintf(prefix, sizeof(prefix), "%s %s: ",
347707ba	105	dev_driver_string(dev), dev_name(dev));
a8ebf98f IPG	106	if (buf_len > 64) {
	107	print_hex_dump(KERN_ERR, prefix, DUMP_PREFIX_OFFSET,
	108	8, 4, buf, 64, 0);
	109	printk(KERN_ERR "%s... (only first 64 bytes "
	110	"dumped)\n", prefix);
	111	} else
	112	print_hex_dump(KERN_ERR, prefix, DUMP_PREFIX_OFFSET,
	113	8, 4, buf, buf_len, 0);
	114	}
	115	error_bad_size:
	116	d_fnend(4, dev, "(i2400m %p buf %p buf_len %zu) = %d\n",
	117	i2400mu, buf, buf_len, ret);
	118	return ret;
	119	}
	120
	121
	122	/*
	123	* URB callback for the notification endpoint
	124	*
	125	* @urb: the urb received from the notification endpoint
	126	*
	127	* This function will just process the USB side of the transaction,
	128	* checking everything is fine, pass the processing to
	129	* i2400m_notification_grok() and resubmit the URB.
	130	*/
	131	static
	132	void i2400mu_notification_cb(struct urb *urb)
	133	{
	134	int ret;
	135	struct i2400mu *i2400mu = urb->context;
	136	struct device *dev = &i2400mu->usb_iface->dev;
	137
	138	d_fnstart(4, dev, "(urb %p status %d actual_length %d)\n",
	139	urb, urb->status, urb->actual_length);
	140	ret = urb->status;
	141	switch (ret) {
	142	case 0:
	143	ret = i2400mu_notification_grok(i2400mu, urb->transfer_buffer,
	144	urb->actual_length);
	145	if (ret == -EIO && edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS,
	146	EDC_ERROR_TIMEFRAME))
	147	goto error_exceeded;
	148	if (ret == -ENOMEM) /* uff...power cycle? shutdown? */
	149	goto error_exceeded;
	150	break;
	151	case -EINVAL: /* while removing driver */
	152	case -ENODEV: /* dev disconnect ... */
	153	case -ENOENT: /* ditto */
	154	case -ESHUTDOWN: /* URB killed */
	155	case -ECONNRESET: /* disconnection */
	156	goto out; /* Notify around */
	157	default: /* Some error? */
	158	if (edc_inc(&i2400mu->urb_edc,
	159	EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME))
	160	goto error_exceeded;
	161	dev_err(dev, "notification: URB error %d, retrying\n",
	162	urb->status);
	163	}
	164	usb_mark_last_busy(i2400mu->usb_dev);
	165	ret = usb_submit_urb(i2400mu->notif_urb, GFP_ATOMIC);
	166	switch (ret) {
	167	case 0:
	168	case -EINVAL: /* while removing driver */
	169	case -ENODEV: /* dev disconnect ... */
170	case -ENOENT: /* ditto */
171	case -ESHUTDOWN: /* URB killed */
172	case -ECONNRESET: /* disconnection */
173	break; /* just ignore */
174	default: /* Some error? */
175	dev_err(dev, "notification: cannot submit URB: %d\n", ret);
176	goto error_submit;
177	}
178	d_fnend(4, dev, "(urb %p status %d actual_length %d) = void\n",
179	urb, urb->status, urb->actual_length);
180	return;
181
182	error_exceeded:
183	dev_err(dev, "maximum errors in notification URB exceeded; "
184	"resetting device\n");
185	error_submit:
186	usb_queue_reset_device(i2400mu->usb_iface);
187	out:
188	d_fnend(4, dev, "(urb %p status %d actual_length %d) = void\n",
189	urb, urb->status, urb->actual_length);
190	return;
191	}
192
193
194	/*
195	* setup the notification endpoint
196	*
197	* @i2400m: device descriptor
198	*
199	* This procedure prepares the notification urb and handler for receiving
200	* unsolicited barkers from the device.
201	*/
202	int i2400mu_notification_setup(struct i2400mu *i2400mu)
203	{
204	struct device *dev = &i2400mu->usb_iface->dev;
205	int usb_pipe, ret = 0;
206	struct usb_endpoint_descriptor *epd;
207	char *buf;
208
209	d_fnstart(4, dev, "(i2400m %p)\n", i2400mu);
210	buf = kmalloc(I2400MU_MAX_NOTIFICATION_LEN, GFP_KERNEL \| GFP_DMA);
211	if (buf == NULL) {
212	dev_err(dev, "notification: buffer allocation failed\n");
213	ret = -ENOMEM;
214	goto error_buf_alloc;
215	}
216
217	i2400mu->notif_urb = usb_alloc_urb(0, GFP_KERNEL);
218	if (!i2400mu->notif_urb) {
219	ret = -ENOMEM;
220	dev_err(dev, "notification: cannot allocate URB\n");
221	goto error_alloc_urb;
222	}
223	epd = usb_get_epd(i2400mu->usb_iface, I2400MU_EP_NOTIFICATION);
224	usb_pipe = usb_rcvintpipe(i2400mu->usb_dev, epd->bEndpointAddress);
225	usb_fill_int_urb(i2400mu->notif_urb, i2400mu->usb_dev, usb_pipe,
226	buf, I2400MU_MAX_NOTIFICATION_LEN,
227	i2400mu_notification_cb, i2400mu, epd->bInterval);
228	ret = usb_submit_urb(i2400mu->notif_urb, GFP_KERNEL);
229	if (ret != 0) {
230	dev_err(dev, "notification: cannot submit URB: %d\n", ret);
231	goto error_submit;
232	}
233	d_fnend(4, dev, "(i2400m %p) = %d\n", i2400mu, ret);
234	return ret;
235
236	error_submit:
237	usb_free_urb(i2400mu->notif_urb);
238	error_alloc_urb:
239	kfree(buf);
240	error_buf_alloc:
241	d_fnend(4, dev, "(i2400m %p) = %d\n", i2400mu, ret);
242	return ret;
243	}
244
245
246	/*
247	* Tear down of the notification mechanism
248	*
249	* @i2400m: device descriptor
250	*
251	* Kill the interrupt endpoint urb, free any allocated resources.
252	*
253	* We need to check if we have done it before as for example,
254	* _suspend() call this; if after a suspend() we get a _disconnect()
255	* (as the case is when hibernating), nothing bad happens.
256	*/
257	void i2400mu_notification_release(struct i2400mu *i2400mu)
258	{
259	struct device *dev = &i2400mu->usb_iface->dev;
260
261	d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu);
262	if (i2400mu->notif_urb != NULL) {
263	usb_kill_urb(i2400mu->notif_urb);
264	kfree(i2400mu->notif_urb->transfer_buffer);
265	usb_free_urb(i2400mu->notif_urb);
266	i2400mu->notif_urb = NULL;
267	}
268	d_fnend(4, dev, "(i2400mu %p)\n", i2400mu);
269	}