3f542990c73f8749c946c513e19645aa31511f73
[linux-2.6.git] / drivers / usb / wusbcore / wa-nep.c
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/uwb/debug.h>
55 #include "wa-hc.h"
56 #include "wusbhc.h"
57
58 /* Structure for queueing notifications to the workqueue */
59 struct wa_notif_work {
60         struct work_struct work;
61         struct wahc *wa;
62         size_t size;
63         u8 data[];
64 };
65
66 /*
67  * Process incoming notifications from the WA's Notification EndPoint
68  * [the wuswad daemon, basically]
69  *
70  * @_nw:        Pointer to a descriptor which has the pointer to the
71  *              @wa, the size of the buffer and the work queue
72  *              structure (so we can free all when done).
73  * @returns     0 if ok, < 0 errno code on error.
74  *
75  * All notifications follow the same format; they need to start with a
76  * 'struct wa_notif_hdr' header, so it is easy to parse through
77  * them. We just break the buffer in individual notifications (the
78  * standard doesn't say if it can be done or is forbidden, so we are
79  * cautious) and dispatch each.
80  *
81  * So the handling layers are is:
82  *
83  *   WA specific notification (from NEP)
84  *      Device Notification Received -> wa_handle_notif_dn()
85  *        WUSB Device notification generic handling
86  *      BPST Adjustment -> wa_handle_notif_bpst_adj()
87  *      ... -> ...
88  *
89  * @wa has to be referenced
90  */
91 static void wa_notif_dispatch(struct work_struct *ws)
92 {
93         void *itr;
94         u8 missing = 0;
95         struct wa_notif_work *nw = container_of(ws, struct wa_notif_work, work);
96         struct wahc *wa = nw->wa;
97         struct wa_notif_hdr *notif_hdr;
98         size_t size;
99
100         struct device *dev = &wa->usb_iface->dev;
101
102 #if 0
103         /* FIXME: need to check for this??? */
104         if (usb_hcd->state == HC_STATE_QUIESCING)       /* Going down? */
105                 goto out;                               /* screw it */
106 #endif
107         atomic_dec(&wa->notifs_queued);         /* Throttling ctl */
108         dev = &wa->usb_iface->dev;
109         size = nw->size;
110         itr = nw->data;
111
112         while (size) {
113                 if (size < sizeof(*notif_hdr)) {
114                         missing = sizeof(*notif_hdr) - size;
115                         goto exhausted_buffer;
116                 }
117                 notif_hdr = itr;
118                 if (size < notif_hdr->bLength)
119                         goto exhausted_buffer;
120                 itr += notif_hdr->bLength;
121                 size -= notif_hdr->bLength;
122                 /* Dispatch the notification [don't use itr or size!] */
123                 switch (notif_hdr->bNotifyType) {
124                 case HWA_NOTIF_DN: {
125                         struct hwa_notif_dn *hwa_dn;
126                         hwa_dn = container_of(notif_hdr, struct hwa_notif_dn,
127                                               hdr);
128                         wusbhc_handle_dn(wa->wusb, hwa_dn->bSourceDeviceAddr,
129                                          hwa_dn->dndata,
130                                          notif_hdr->bLength - sizeof(*hwa_dn));
131                         break;
132                 }
133                 case WA_NOTIF_TRANSFER:
134                         wa_handle_notif_xfer(wa, notif_hdr);
135                         break;
136                 case DWA_NOTIF_RWAKE:
137                 case DWA_NOTIF_PORTSTATUS:
138                 case HWA_NOTIF_BPST_ADJ:
139                         /* FIXME: unimplemented WA NOTIFs */
140                         /* fallthru */
141                 default:
142                         if (printk_ratelimit()) {
143                                 dev_err(dev, "HWA: unknown notification 0x%x, "
144                                         "%zu bytes; discarding\n",
145                                         notif_hdr->bNotifyType,
146                                         (size_t)notif_hdr->bLength);
147                                 dump_bytes(dev, notif_hdr, 16);
148                         }
149                         break;
150                 }
151         }
152 out:
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          */
162 exhausted_buffer:
163         if (!printk_ratelimit())
164                 goto out;
165         dev_warn(dev, "HWA: device sent short notification, "
166                  "%d bytes missing; discarding %d bytes.\n",
167                  missing, (int)size);
168         dump_bytes(dev, itr, size);
169         goto out;
170 }
171
172 /*
173  * Deliver incoming WA notifications to the wusbwa workqueue
174  *
175  * @wa: Pointer the Wire Adapter Controller Data Streaming
176  *              instance (part of an 'struct usb_hcd').
177  * @size:       Size of the received buffer
178  * @returns     0 if ok, < 0 errno code on error.
179  *
180  * The input buffer is @wa->nep_buffer, with @size bytes
181  * (guaranteed to fit in the allocated space,
182  * @wa->nep_buffer_size).
183  */
184 static int wa_nep_queue(struct wahc *wa, size_t size)
185 {
186         int result = 0;
187         struct device *dev = &wa->usb_iface->dev;
188         struct wa_notif_work *nw;
189
190         /* dev_fnstart(dev, "(wa %p, size %zu)\n", wa, size); */
191         BUG_ON(size > wa->nep_buffer_size);
192         if (size == 0)
193                 goto out;
194         if (atomic_read(&wa->notifs_queued) > 200) {
195                 if (printk_ratelimit())
196                         dev_err(dev, "Too many notifications queued, "
197                                 "throttling back\n");
198                 goto out;
199         }
200         nw = kzalloc(sizeof(*nw) + size, GFP_ATOMIC);
201         if (nw == NULL) {
202                 if (printk_ratelimit())
203                         dev_err(dev, "No memory to queue notification\n");
204                 goto out;
205         }
206         INIT_WORK(&nw->work, wa_notif_dispatch);
207         nw->wa = wa_get(wa);
208         nw->size = size;
209         memcpy(nw->data, wa->nep_buffer, size);
210         atomic_inc(&wa->notifs_queued);         /* Throttling ctl */
211         queue_work(wusbd, &nw->work);
212 out:
213         /* dev_fnend(dev, "(wa %p, size %zu) = result\n", wa, size, result); */
214         return result;
215 }
216
217 /*
218  * Callback for the notification event endpoint
219  *
220  * Check's that everything is fine and then passes the data to be
221  * queued to the workqueue.
222  */
223 static void wa_nep_cb(struct urb *urb)
224 {
225         int result;
226         struct wahc *wa = urb->context;
227         struct device *dev = &wa->usb_iface->dev;
228
229         switch (result = urb->status) {
230         case 0:
231                 result = wa_nep_queue(wa, urb->actual_length);
232                 if (result < 0)
233                         dev_err(dev, "NEP: unable to process notification(s): "
234                                 "%d\n", result);
235                 break;
236         case -ECONNRESET:       /* Not an error, but a controlled situation; */
237         case -ENOENT:           /* (we killed the URB)...so, no broadcast */
238         case -ESHUTDOWN:
239                 dev_dbg(dev, "NEP: going down %d\n", urb->status);
240                 goto out;
241         default:        /* On general errors, we retry unless it gets ugly */
242                 if (edc_inc(&wa->nep_edc, EDC_MAX_ERRORS,
243                             EDC_ERROR_TIMEFRAME)) {
244                         dev_err(dev, "NEP: URB max acceptable errors "
245                                 "exceeded, resetting device\n");
246                         wa_reset_all(wa);
247                         goto out;
248                 }
249                 dev_err(dev, "NEP: URB error %d\n", urb->status);
250         }
251         result = wa_nep_arm(wa, GFP_ATOMIC);
252         if (result < 0) {
253                 dev_err(dev, "NEP: cannot submit URB: %d\n", result);
254                 wa_reset_all(wa);
255         }
256 out:
257         return;
258 }
259
260 /*
261  * Initialize @wa's notification and event's endpoint stuff
262  *
263  * This includes the allocating the read buffer, the context ID
264  * allocation bitmap, the URB and submitting the URB.
265  */
266 int wa_nep_create(struct wahc *wa, struct usb_interface *iface)
267 {
268         int result;
269         struct usb_endpoint_descriptor *epd;
270         struct usb_device *usb_dev = interface_to_usbdev(iface);
271         struct device *dev = &iface->dev;
272
273         edc_init(&wa->nep_edc);
274         epd = &iface->cur_altsetting->endpoint[0].desc;
275         wa->nep_buffer_size = 1024;
276         wa->nep_buffer = kmalloc(wa->nep_buffer_size, GFP_KERNEL);
277         if (wa->nep_buffer == NULL) {
278                 dev_err(dev, "Unable to allocate notification's read buffer\n");
279                 goto error_nep_buffer;
280         }
281         wa->nep_urb = usb_alloc_urb(0, GFP_KERNEL);
282         if (wa->nep_urb == NULL) {
283                 dev_err(dev, "Unable to allocate notification URB\n");
284                 goto error_urb_alloc;
285         }
286         usb_fill_int_urb(wa->nep_urb, usb_dev,
287                          usb_rcvintpipe(usb_dev, epd->bEndpointAddress),
288                          wa->nep_buffer, wa->nep_buffer_size,
289                          wa_nep_cb, wa, epd->bInterval);
290         result = wa_nep_arm(wa, GFP_KERNEL);
291         if (result < 0) {
292                 dev_err(dev, "Cannot submit notification URB: %d\n", result);
293                 goto error_nep_arm;
294         }
295         return 0;
296
297 error_nep_arm:
298         usb_free_urb(wa->nep_urb);
299 error_urb_alloc:
300         kfree(wa->nep_buffer);
301 error_nep_buffer:
302         return -ENOMEM;
303 }
304
305 void wa_nep_destroy(struct wahc *wa)
306 {
307         wa_nep_disarm(wa);
308         usb_free_urb(wa->nep_urb);
309         kfree(wa->nep_buffer);
310 }