2 * WUSB Wire Adapter: Control/Data Streaming Interface (WUSB[8])
3 * Notification EndPoint support
5 * Copyright (C) 2006 Intel Corporation
6 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
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.
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.
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
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.
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]).
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).
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.
44 * Entry points here are:
46 * wa_nep_[create|destroy]() To initialize/release this subsystem
48 * wa_nep_cb() Callback for the notification
49 * endpoint; when data is ready, this
50 * does the dispatching.
52 #include <linux/workqueue.h>
53 #include <linux/ctype.h>
54 #include <linux/slab.h>
59 /* Structure for queueing notifications to the workqueue */
60 struct wa_notif_work
{
61 struct work_struct work
;
68 * Process incoming notifications from the WA's Notification EndPoint
69 * [the wuswad daemon, basically]
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.
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.
82 * So the handling layers are is:
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()
90 * @wa has to be referenced
92 static void wa_notif_dispatch(struct work_struct
*ws
)
96 struct wa_notif_work
*nw
= container_of(ws
, struct wa_notif_work
,
98 struct wahc
*wa
= nw
->wa
;
99 struct wa_notif_hdr
*notif_hdr
;
102 struct device
*dev
= &wa
->usb_iface
->dev
;
105 /* FIXME: need to check for this??? */
106 if (usb_hcd
->state
== HC_STATE_QUIESCING
) /* Going down? */
107 goto out
; /* screw it */
109 atomic_dec(&wa
->notifs_queued
); /* Throttling ctl */
110 dev
= &wa
->usb_iface
->dev
;
115 if (size
< sizeof(*notif_hdr
)) {
116 missing
= sizeof(*notif_hdr
) - size
;
117 goto exhausted_buffer
;
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
) {
127 struct hwa_notif_dn
*hwa_dn
;
128 hwa_dn
= container_of(notif_hdr
, struct hwa_notif_dn
,
130 wusbhc_handle_dn(wa
->wusb
, hwa_dn
->bSourceDeviceAddr
,
132 notif_hdr
->bLength
- sizeof(*hwa_dn
));
135 case WA_NOTIF_TRANSFER
:
136 wa_handle_notif_xfer(wa
, notif_hdr
);
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 */
145 dev_err(dev
, "HWA: unknown notification 0x%x, "
146 "%zu bytes; discarding\n",
147 notif_hdr
->bNotifyType
,
148 (size_t)notif_hdr
->bLength
);
157 /* THIS SHOULD NOT HAPPEN
159 * Buffer exahusted with partial data remaining; just warn and
160 * discard the data, as this should not happen.
163 dev_warn(dev
, "HWA: device sent short notification, "
164 "%d bytes missing; discarding %d bytes.\n",
170 * Deliver incoming WA notifications to the wusbwa workqueue
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.
177 * The input buffer is @wa->nep_buffer, with @size bytes
178 * (guaranteed to fit in the allocated space,
179 * @wa->nep_buffer_size).
181 static int wa_nep_queue(struct wahc
*wa
, size_t size
)
184 struct device
*dev
= &wa
->usb_iface
->dev
;
185 struct wa_notif_work
*nw
;
187 /* dev_fnstart(dev, "(wa %p, size %zu)\n", wa, size); */
188 BUG_ON(size
> wa
->nep_buffer_size
);
191 if (atomic_read(&wa
->notifs_queued
) > 200) {
192 if (printk_ratelimit())
193 dev_err(dev
, "Too many notifications queued, "
194 "throttling back\n");
197 nw
= kzalloc(sizeof(*nw
) + size
, GFP_ATOMIC
);
199 if (printk_ratelimit())
200 dev_err(dev
, "No memory to queue notification\n");
203 INIT_WORK(&nw
->work
, wa_notif_dispatch
);
206 memcpy(nw
->data
, wa
->nep_buffer
, size
);
207 atomic_inc(&wa
->notifs_queued
); /* Throttling ctl */
208 queue_work(wusbd
, &nw
->work
);
210 /* dev_fnend(dev, "(wa %p, size %zu) = result\n", wa, size, result); */
215 * Callback for the notification event endpoint
217 * Check's that everything is fine and then passes the data to be
218 * queued to the workqueue.
220 static void wa_nep_cb(struct urb
*urb
)
223 struct wahc
*wa
= urb
->context
;
224 struct device
*dev
= &wa
->usb_iface
->dev
;
226 switch (result
= urb
->status
) {
228 result
= wa_nep_queue(wa
, urb
->actual_length
);
230 dev_err(dev
, "NEP: unable to process notification(s): "
233 case -ECONNRESET
: /* Not an error, but a controlled situation; */
234 case -ENOENT
: /* (we killed the URB)...so, no broadcast */
236 dev_dbg(dev
, "NEP: going down %d\n", urb
->status
);
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");
246 dev_err(dev
, "NEP: URB error %d\n", urb
->status
);
248 result
= wa_nep_arm(wa
, GFP_ATOMIC
);
250 dev_err(dev
, "NEP: cannot submit URB: %d\n", result
);
258 * Initialize @wa's notification and event's endpoint stuff
260 * This includes the allocating the read buffer, the context ID
261 * allocation bitmap, the URB and submitting the URB.
263 int wa_nep_create(struct wahc
*wa
, struct usb_interface
*iface
)
266 struct usb_endpoint_descriptor
*epd
;
267 struct usb_device
*usb_dev
= interface_to_usbdev(iface
);
268 struct device
*dev
= &iface
->dev
;
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
) {
276 "Unable to allocate notification's read buffer\n");
277 goto error_nep_buffer
;
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
;
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
);
290 dev_err(dev
, "Cannot submit notification URB: %d\n", result
);
296 usb_free_urb(wa
->nep_urb
);
298 kfree(wa
->nep_buffer
);
303 void wa_nep_destroy(struct wahc
*wa
)
306 usb_free_urb(wa
->nep_urb
);
307 kfree(wa
->nep_buffer
);