1/*
2 * WUSB Wire Adapter: Control/Data Streaming Interface (WUSB[8])
3 * Notification EndPoint support
4 *
5 * Copyright (C) 2006 Intel Corporation
6 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License version
10 * 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 * 02110-1301, USA.
21 *
22 *
23 * This part takes care of getting the notification from the hw
24 * only and dispatching through wusbwad into
25 * wa_notif_dispatch. Handling is done there.
26 *
27 * WA notifications are limited in size; most of them are three or
28 * four bytes long, and the longest is the HWA Device Notification,
29 * which would not exceed 38 bytes (DNs are limited in payload to 32
30 * bytes plus 3 bytes header (WUSB1.0[7.6p2]), plus 3 bytes HWA
31 * header (WUSB1.0[8.5.4.2]).
32 *
33 * It is not clear if more than one Device Notification can be packed
34 * in a HWA Notification, I assume no because of the wording in
35 * WUSB1.0[8.5.4.2]. In any case, the bigger any notification could
36 * get is 256 bytes (as the bLength field is a byte).
37 *
38 * So what we do is we have this buffer and read into it; when a
39 * notification arrives we schedule work to a specific, single thread
40 * workqueue (so notifications are serialized) and copy the
41 * notification data. After scheduling the work, we rearm the read from
42 * the notification endpoint.
43 *
44 * Entry points here are:
45 *
46 * wa_nep_[create|destroy]()   To initialize/release this subsystem
47 *
48 * wa_nep_cb()                 Callback for the notification
49 *                                endpoint; when data is ready, this
50 *                                does the dispatching.
51 */
52#include <linux/workqueue.h>
53#include <linux/ctype.h>
54#include <linux/slab.h>
55
56#include "wa-hc.h"
57#include "wusbhc.h"
58
59/* Structure for queueing notifications to the workqueue */
60struct wa_notif_work {
61	struct work_struct work;
62	struct wahc *wa;
63	size_t size;
64	u8 data[];
65};
66
67/*
68 * Process incoming notifications from the WA's Notification EndPoint
69 * [the wuswad daemon, basically]
70 *
71 * @_nw:	Pointer to a descriptor which has the pointer to the
72 *		@wa, the size of the buffer and the work queue
73 *		structure (so we can free all when done).
74 * @returns     0 if ok, < 0 errno code on error.
75 *
76 * All notifications follow the same format; they need to start with a
77 * 'struct wa_notif_hdr' header, so it is easy to parse through
78 * them. We just break the buffer in individual notifications (the
79 * standard doesn't say if it can be done or is forbidden, so we are
80 * cautious) and dispatch each.
81 *
82 * So the handling layers are is:
83 *
84 *   WA specific notification (from NEP)
85 *      Device Notification Received -> wa_handle_notif_dn()
86 *        WUSB Device notification generic handling
87 *      BPST Adjustment -> wa_handle_notif_bpst_adj()
88 *      ... -> ...
89 *
90 * @wa has to be referenced
91 */
92static void wa_notif_dispatch(struct work_struct *ws)
93{
94	void *itr;
95	u8 missing = 0;
96	struct wa_notif_work *nw = container_of(ws, struct wa_notif_work,
97						work);
98	struct wahc *wa = nw->wa;
99	struct wa_notif_hdr *notif_hdr;
100	size_t size;
101
102	struct device *dev = &wa->usb_iface->dev;
103
104#if 0
105	/* FIXME: need to check for this??? */
106	if (usb_hcd->state == HC_STATE_QUIESCING)	/* Going down? */
107		goto out;				/* screw it */
108#endif
109	atomic_dec(&wa->notifs_queued);		/* Throttling ctl */
110	dev = &wa->usb_iface->dev;
111	size = nw->size;
112	itr = nw->data;
113
114	while (size) {
115		if (size < sizeof(*notif_hdr)) {
116			missing = sizeof(*notif_hdr) - size;
117			goto exhausted_buffer;
118		}
119		notif_hdr = itr;
120		if (size < notif_hdr->bLength)
121			goto exhausted_buffer;
122		itr += notif_hdr->bLength;
123		size -= notif_hdr->bLength;
124		/* Dispatch the notification [don't use itr or size!] */
125		switch (notif_hdr->bNotifyType) {
126		case HWA_NOTIF_DN: {
127			struct hwa_notif_dn *hwa_dn;
128			hwa_dn = container_of(notif_hdr, struct hwa_notif_dn,
129					      hdr);
130			wusbhc_handle_dn(wa->wusb, hwa_dn->bSourceDeviceAddr,
131					 hwa_dn->dndata,
132					 notif_hdr->bLength - sizeof(*hwa_dn));
133			break;
134		}
135		case WA_NOTIF_TRANSFER:
136			wa_handle_notif_xfer(wa, notif_hdr);
137			break;
138		case HWA_NOTIF_BPST_ADJ:
139			break; /* no action needed for BPST ADJ. */
140		case DWA_NOTIF_RWAKE:
141		case DWA_NOTIF_PORTSTATUS:
142			/* FIXME: unimplemented WA NOTIFs */
143			/* fallthru */
144		default:
145			dev_err(dev, "HWA: unknown notification 0x%x, "
146				"%zu bytes; discarding\n",
147				notif_hdr->bNotifyType,
148				(size_t)notif_hdr->bLength);
149			break;
150		}
151	}
152out:
153	wa_put(wa);
154	kfree(nw);
155	return;
156
157	/* THIS SHOULD NOT HAPPEN
158	 *
159	 * Buffer exahusted with partial data remaining; just warn and
160	 * discard the data, as this should not happen.
161	 */
162exhausted_buffer:
163	dev_warn(dev, "HWA: device sent short notification, "
164		 "%d bytes missing; discarding %d bytes.\n",
165		 missing, (int)size);
166	goto out;
167}
168
169/*
170 * Deliver incoming WA notifications to the wusbwa workqueue
171 *
172 * @wa:	Pointer the Wire Adapter Controller Data Streaming
173 *              instance (part of an 'struct usb_hcd').
174 * @size:       Size of the received buffer
175 * @returns     0 if ok, < 0 errno code on error.
176 *
177 * The input buffer is @wa->nep_buffer, with @size bytes
178 * (guaranteed to fit in the allocated space,
179 * @wa->nep_buffer_size).
180 */
181static int wa_nep_queue(struct wahc *wa, size_t size)
182{
183	int result = 0;
184	struct device *dev = &wa->usb_iface->dev;
185	struct wa_notif_work *nw;
186
187	/* dev_fnstart(dev, "(wa %p, size %zu)\n", wa, size); */
188	BUG_ON(size > wa->nep_buffer_size);
189	if (size == 0)
190		goto out;
191	if (atomic_read(&wa->notifs_queued) > 200) {
192		if (printk_ratelimit())
193			dev_err(dev, "Too many notifications queued, "
194				"throttling back\n");
195		goto out;
196	}
197	nw = kzalloc(sizeof(*nw) + size, GFP_ATOMIC);
198	if (nw == NULL) {
199		if (printk_ratelimit())
200			dev_err(dev, "No memory to queue notification\n");
201		goto out;
202	}
203	INIT_WORK(&nw->work, wa_notif_dispatch);
204	nw->wa = wa_get(wa);
205	nw->size = size;
206	memcpy(nw->data, wa->nep_buffer, size);
207	atomic_inc(&wa->notifs_queued);		/* Throttling ctl */
208	queue_work(wusbd, &nw->work);
209out:
210	/* dev_fnend(dev, "(wa %p, size %zu) = result\n", wa, size, result); */
211	return result;
212}
213
214/*
215 * Callback for the notification event endpoint
216 *
217 * Check's that everything is fine and then passes the data to be
218 * queued to the workqueue.
219 */
220static void wa_nep_cb(struct urb *urb)
221{
222	int result;
223	struct wahc *wa = urb->context;
224	struct device *dev = &wa->usb_iface->dev;
225
226	switch (result = urb->status) {
227	case 0:
228		result = wa_nep_queue(wa, urb->actual_length);
229		if (result < 0)
230			dev_err(dev, "NEP: unable to process notification(s): "
231				"%d\n", result);
232		break;
233	case -ECONNRESET:	/* Not an error, but a controlled situation; */
234	case -ENOENT:		/* (we killed the URB)...so, no broadcast */
235	case -ESHUTDOWN:
236		dev_dbg(dev, "NEP: going down %d\n", urb->status);
237		goto out;
238	default:	/* On general errors, we retry unless it gets ugly */
239		if (edc_inc(&wa->nep_edc, EDC_MAX_ERRORS,
240			    EDC_ERROR_TIMEFRAME)) {
241			dev_err(dev, "NEP: URB max acceptable errors "
242				"exceeded, resetting device\n");
243			wa_reset_all(wa);
244			goto out;
245		}
246		dev_err(dev, "NEP: URB error %d\n", urb->status);
247	}
248	result = wa_nep_arm(wa, GFP_ATOMIC);
249	if (result < 0) {
250		dev_err(dev, "NEP: cannot submit URB: %d\n", result);
251		wa_reset_all(wa);
252	}
253out:
254	return;
255}
256
257/*
258 * Initialize @wa's notification and event's endpoint stuff
259 *
260 * This includes the allocating the read buffer, the context ID
261 * allocation bitmap, the URB and submitting the URB.
262 */
263int wa_nep_create(struct wahc *wa, struct usb_interface *iface)
264{
265	int result;
266	struct usb_endpoint_descriptor *epd;
267	struct usb_device *usb_dev = interface_to_usbdev(iface);
268	struct device *dev = &iface->dev;
269
270	edc_init(&wa->nep_edc);
271	epd = &iface->cur_altsetting->endpoint[0].desc;
272	wa->nep_buffer_size = 1024;
273	wa->nep_buffer = kmalloc(wa->nep_buffer_size, GFP_KERNEL);
274	if (wa->nep_buffer == NULL) {
275		dev_err(dev,
276			"Unable to allocate notification's read buffer\n");
277		goto error_nep_buffer;
278	}
279	wa->nep_urb = usb_alloc_urb(0, GFP_KERNEL);
280	if (wa->nep_urb == NULL) {
281		dev_err(dev, "Unable to allocate notification URB\n");
282		goto error_urb_alloc;
283	}
284	usb_fill_int_urb(wa->nep_urb, usb_dev,
285			 usb_rcvintpipe(usb_dev, epd->bEndpointAddress),
286			 wa->nep_buffer, wa->nep_buffer_size,
287			 wa_nep_cb, wa, epd->bInterval);
288	result = wa_nep_arm(wa, GFP_KERNEL);
289	if (result < 0) {
290		dev_err(dev, "Cannot submit notification URB: %d\n", result);
291		goto error_nep_arm;
292	}
293	return 0;
294
295error_nep_arm:
296	usb_free_urb(wa->nep_urb);
297error_urb_alloc:
298	kfree(wa->nep_buffer);
299error_nep_buffer:
300	return -ENOMEM;
301}
302
303void wa_nep_destroy(struct wahc *wa)
304{
305	wa_nep_disarm(wa);
306	usb_free_urb(wa->nep_urb);
307	kfree(wa->nep_buffer);
308}
309