blob: bab5672665597b29f28ea6c6b3f7b3c948fba1d9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Universal Host Controller Interface driver for USB.
3 *
4 * Maintainer: Alan Stern <stern@rowland.harvard.edu>
5 *
6 * (C) Copyright 1999 Linus Torvalds
7 * (C) Copyright 1999-2002 Johannes Erdfelt, johannes@erdfelt.com
8 * (C) Copyright 1999 Randy Dunlap
9 * (C) Copyright 1999 Georg Acher, acher@in.tum.de
10 * (C) Copyright 1999 Deti Fliegl, deti@fliegl.de
11 * (C) Copyright 1999 Thomas Sailer, sailer@ife.ee.ethz.ch
12 * (C) Copyright 1999 Roman Weissgaerber, weissg@vienna.at
13 * (C) Copyright 2000 Yggdrasil Computing, Inc. (port of new PCI interface
14 * support from usb-ohci.c by Adam Richter, adam@yggdrasil.com).
15 * (C) Copyright 1999 Gregory P. Smith (from usb-ohci.c)
Alan Stern17230ac2007-02-19 15:52:45 -050016 * (C) Copyright 2004-2007 Alan Stern, stern@rowland.harvard.edu
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
18
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
20/*
21 * Technically, updating td->status here is a race, but it's not really a
22 * problem. The worst that can happen is that we set the IOC bit again
23 * generating a spurious interrupt. We could fix this by creating another
24 * QH and leaving the IOC bit always set, but then we would have to play
25 * games with the FSBR code to make sure we get the correct order in all
26 * the cases. I don't think it's worth the effort
27 */
Alan Sterndccf4a42005-12-17 17:58:46 -050028static void uhci_set_next_interrupt(struct uhci_hcd *uhci)
Linus Torvalds1da177e2005-04-16 15:20:36 -070029{
Alan Stern6c1b4452005-04-21 16:04:58 -040030 if (uhci->is_stopped)
Alan Stern1f09df82005-09-05 13:59:51 -040031 mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 uhci->term_td->status |= cpu_to_le32(TD_CTRL_IOC);
33}
34
35static inline void uhci_clear_next_interrupt(struct uhci_hcd *uhci)
36{
37 uhci->term_td->status &= ~cpu_to_le32(TD_CTRL_IOC);
38}
39
Alan Stern84afddd2006-05-12 11:35:45 -040040
41/*
42 * Full-Speed Bandwidth Reclamation (FSBR).
43 * We turn on FSBR whenever a queue that wants it is advancing,
44 * and leave it on for a short time thereafter.
45 */
46static void uhci_fsbr_on(struct uhci_hcd *uhci)
47{
Alan Sterne009f1b2007-03-19 15:31:42 -040048 struct uhci_qh *lqh;
Alan Stern17230ac2007-02-19 15:52:45 -050049
Alan Sterne009f1b2007-03-19 15:31:42 -040050 /* The terminating skeleton QH always points back to the first
51 * FSBR QH. Make the last async QH point to the terminating
52 * skeleton QH. */
Alan Stern84afddd2006-05-12 11:35:45 -040053 uhci->fsbr_is_on = 1;
Alan Stern17230ac2007-02-19 15:52:45 -050054 lqh = list_entry(uhci->skel_async_qh->node.prev,
55 struct uhci_qh, node);
Alan Sterne009f1b2007-03-19 15:31:42 -040056 lqh->link = LINK_TO_QH(uhci->skel_term_qh);
Alan Stern84afddd2006-05-12 11:35:45 -040057}
58
59static void uhci_fsbr_off(struct uhci_hcd *uhci)
60{
Alan Stern17230ac2007-02-19 15:52:45 -050061 struct uhci_qh *lqh;
62
Alan Sterne009f1b2007-03-19 15:31:42 -040063 /* Remove the link from the last async QH to the terminating
64 * skeleton QH. */
Alan Stern84afddd2006-05-12 11:35:45 -040065 uhci->fsbr_is_on = 0;
Alan Stern17230ac2007-02-19 15:52:45 -050066 lqh = list_entry(uhci->skel_async_qh->node.prev,
67 struct uhci_qh, node);
Alan Sterne009f1b2007-03-19 15:31:42 -040068 lqh->link = UHCI_PTR_TERM;
Alan Stern84afddd2006-05-12 11:35:45 -040069}
70
71static void uhci_add_fsbr(struct uhci_hcd *uhci, struct urb *urb)
72{
73 struct urb_priv *urbp = urb->hcpriv;
74
75 if (!(urb->transfer_flags & URB_NO_FSBR))
76 urbp->fsbr = 1;
77}
78
Alan Sternc5e3b742006-06-05 12:28:57 -040079static void uhci_urbp_wants_fsbr(struct uhci_hcd *uhci, struct urb_priv *urbp)
Alan Stern84afddd2006-05-12 11:35:45 -040080{
Alan Stern84afddd2006-05-12 11:35:45 -040081 if (urbp->fsbr) {
Alan Sternc5e3b742006-06-05 12:28:57 -040082 uhci->fsbr_is_wanted = 1;
Alan Stern84afddd2006-05-12 11:35:45 -040083 if (!uhci->fsbr_is_on)
84 uhci_fsbr_on(uhci);
Alan Sternc5e3b742006-06-05 12:28:57 -040085 else if (uhci->fsbr_expiring) {
86 uhci->fsbr_expiring = 0;
87 del_timer(&uhci->fsbr_timer);
88 }
Alan Stern84afddd2006-05-12 11:35:45 -040089 }
90}
91
Alan Sternc5e3b742006-06-05 12:28:57 -040092static void uhci_fsbr_timeout(unsigned long _uhci)
93{
94 struct uhci_hcd *uhci = (struct uhci_hcd *) _uhci;
95 unsigned long flags;
96
97 spin_lock_irqsave(&uhci->lock, flags);
98 if (uhci->fsbr_expiring) {
99 uhci->fsbr_expiring = 0;
100 uhci_fsbr_off(uhci);
101 }
102 spin_unlock_irqrestore(&uhci->lock, flags);
103}
104
Alan Stern84afddd2006-05-12 11:35:45 -0400105
Alan Stern25321782005-04-25 11:14:31 -0400106static struct uhci_td *uhci_alloc_td(struct uhci_hcd *uhci)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107{
108 dma_addr_t dma_handle;
109 struct uhci_td *td;
110
111 td = dma_pool_alloc(uhci->td_pool, GFP_ATOMIC, &dma_handle);
112 if (!td)
113 return NULL;
114
115 td->dma_handle = dma_handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 td->frame = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118 INIT_LIST_HEAD(&td->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 INIT_LIST_HEAD(&td->fl_list);
120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 return td;
122}
123
Alan Sterndccf4a42005-12-17 17:58:46 -0500124static void uhci_free_td(struct uhci_hcd *uhci, struct uhci_td *td)
125{
Alan Stern0cef7722007-03-19 15:33:11 -0400126 if (!list_empty(&td->list)) {
Alan Sterndccf4a42005-12-17 17:58:46 -0500127 dev_warn(uhci_dev(uhci), "td %p still in list!\n", td);
Alan Stern0cef7722007-03-19 15:33:11 -0400128 WARN_ON(1);
129 }
130 if (!list_empty(&td->fl_list)) {
Alan Sterndccf4a42005-12-17 17:58:46 -0500131 dev_warn(uhci_dev(uhci), "td %p still in fl_list!\n", td);
Alan Stern0cef7722007-03-19 15:33:11 -0400132 WARN_ON(1);
133 }
Alan Sterndccf4a42005-12-17 17:58:46 -0500134
135 dma_pool_free(uhci->td_pool, td, td->dma_handle);
136}
137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138static inline void uhci_fill_td(struct uhci_td *td, u32 status,
139 u32 token, u32 buffer)
140{
141 td->status = cpu_to_le32(status);
142 td->token = cpu_to_le32(token);
143 td->buffer = cpu_to_le32(buffer);
144}
145
Alan Stern04538a22006-05-12 11:29:04 -0400146static void uhci_add_td_to_urbp(struct uhci_td *td, struct urb_priv *urbp)
147{
148 list_add_tail(&td->list, &urbp->td_list);
149}
150
151static void uhci_remove_td_from_urbp(struct uhci_td *td)
152{
153 list_del_init(&td->list);
154}
155
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156/*
Alan Stern687f5f32005-11-30 17:16:19 -0500157 * We insert Isochronous URBs directly into the frame list at the beginning
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 */
Alan Sterndccf4a42005-12-17 17:58:46 -0500159static inline void uhci_insert_td_in_frame_list(struct uhci_hcd *uhci,
160 struct uhci_td *td, unsigned framenum)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161{
162 framenum &= (UHCI_NUMFRAMES - 1);
163
164 td->frame = framenum;
165
166 /* Is there a TD already mapped there? */
Alan Sterna1d59ce2005-09-16 14:22:51 -0400167 if (uhci->frame_cpu[framenum]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 struct uhci_td *ftd, *ltd;
169
Alan Sterna1d59ce2005-09-16 14:22:51 -0400170 ftd = uhci->frame_cpu[framenum];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 ltd = list_entry(ftd->fl_list.prev, struct uhci_td, fl_list);
172
173 list_add_tail(&td->fl_list, &ftd->fl_list);
174
175 td->link = ltd->link;
176 wmb();
Alan Stern28b93252007-02-19 15:51:51 -0500177 ltd->link = LINK_TO_TD(td);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 } else {
Alan Sterna1d59ce2005-09-16 14:22:51 -0400179 td->link = uhci->frame[framenum];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 wmb();
Alan Stern28b93252007-02-19 15:51:51 -0500181 uhci->frame[framenum] = LINK_TO_TD(td);
Alan Sterna1d59ce2005-09-16 14:22:51 -0400182 uhci->frame_cpu[framenum] = td;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 }
184}
185
Alan Sterndccf4a42005-12-17 17:58:46 -0500186static inline void uhci_remove_td_from_frame_list(struct uhci_hcd *uhci,
Alan Sternb81d3432005-10-13 17:00:24 -0400187 struct uhci_td *td)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188{
189 /* If it's not inserted, don't remove it */
Alan Sternb81d3432005-10-13 17:00:24 -0400190 if (td->frame == -1) {
191 WARN_ON(!list_empty(&td->fl_list));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 return;
Alan Sternb81d3432005-10-13 17:00:24 -0400193 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
Alan Sternb81d3432005-10-13 17:00:24 -0400195 if (uhci->frame_cpu[td->frame] == td) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 if (list_empty(&td->fl_list)) {
Alan Sterna1d59ce2005-09-16 14:22:51 -0400197 uhci->frame[td->frame] = td->link;
198 uhci->frame_cpu[td->frame] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 } else {
200 struct uhci_td *ntd;
201
202 ntd = list_entry(td->fl_list.next, struct uhci_td, fl_list);
Alan Stern28b93252007-02-19 15:51:51 -0500203 uhci->frame[td->frame] = LINK_TO_TD(ntd);
Alan Sterna1d59ce2005-09-16 14:22:51 -0400204 uhci->frame_cpu[td->frame] = ntd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 }
206 } else {
207 struct uhci_td *ptd;
208
209 ptd = list_entry(td->fl_list.prev, struct uhci_td, fl_list);
210 ptd->link = td->link;
211 }
212
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 list_del_init(&td->fl_list);
214 td->frame = -1;
215}
216
Alan Sternc8155cc2006-05-19 16:52:35 -0400217static inline void uhci_remove_tds_from_frame(struct uhci_hcd *uhci,
218 unsigned int framenum)
219{
220 struct uhci_td *ftd, *ltd;
221
222 framenum &= (UHCI_NUMFRAMES - 1);
223
224 ftd = uhci->frame_cpu[framenum];
225 if (ftd) {
226 ltd = list_entry(ftd->fl_list.prev, struct uhci_td, fl_list);
227 uhci->frame[framenum] = ltd->link;
228 uhci->frame_cpu[framenum] = NULL;
229
230 while (!list_empty(&ftd->fl_list))
231 list_del_init(ftd->fl_list.prev);
232 }
233}
234
Alan Sterndccf4a42005-12-17 17:58:46 -0500235/*
236 * Remove all the TDs for an Isochronous URB from the frame list
237 */
238static void uhci_unlink_isochronous_tds(struct uhci_hcd *uhci, struct urb *urb)
Alan Sternb81d3432005-10-13 17:00:24 -0400239{
240 struct urb_priv *urbp = (struct urb_priv *) urb->hcpriv;
241 struct uhci_td *td;
242
243 list_for_each_entry(td, &urbp->td_list, list)
Alan Sterndccf4a42005-12-17 17:58:46 -0500244 uhci_remove_td_from_frame_list(uhci, td);
Alan Sternb81d3432005-10-13 17:00:24 -0400245}
246
Alan Sterndccf4a42005-12-17 17:58:46 -0500247static struct uhci_qh *uhci_alloc_qh(struct uhci_hcd *uhci,
248 struct usb_device *udev, struct usb_host_endpoint *hep)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249{
250 dma_addr_t dma_handle;
251 struct uhci_qh *qh;
252
253 qh = dma_pool_alloc(uhci->qh_pool, GFP_ATOMIC, &dma_handle);
254 if (!qh)
255 return NULL;
256
Alan Stern59e29ed2006-05-12 11:19:19 -0400257 memset(qh, 0, sizeof(*qh));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 qh->dma_handle = dma_handle;
259
260 qh->element = UHCI_PTR_TERM;
261 qh->link = UHCI_PTR_TERM;
262
Alan Sterndccf4a42005-12-17 17:58:46 -0500263 INIT_LIST_HEAD(&qh->queue);
264 INIT_LIST_HEAD(&qh->node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
Alan Sterndccf4a42005-12-17 17:58:46 -0500266 if (udev) { /* Normal QH */
Alan Stern85a975d2007-01-08 12:01:43 -0500267 qh->type = hep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
268 if (qh->type != USB_ENDPOINT_XFER_ISOC) {
269 qh->dummy_td = uhci_alloc_td(uhci);
270 if (!qh->dummy_td) {
271 dma_pool_free(uhci->qh_pool, qh, dma_handle);
272 return NULL;
273 }
Alan Sternaf0bb592005-12-17 18:00:12 -0500274 }
Alan Sterndccf4a42005-12-17 17:58:46 -0500275 qh->state = QH_STATE_IDLE;
276 qh->hep = hep;
277 qh->udev = udev;
278 hep->hcpriv = qh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279
Alan Stern3ca2a322007-01-16 11:56:32 -0500280 if (qh->type == USB_ENDPOINT_XFER_INT ||
281 qh->type == USB_ENDPOINT_XFER_ISOC)
282 qh->load = usb_calc_bus_time(udev->speed,
283 usb_endpoint_dir_in(&hep->desc),
284 qh->type == USB_ENDPOINT_XFER_ISOC,
285 le16_to_cpu(hep->desc.wMaxPacketSize))
286 / 1000 + 1;
287
Alan Sterndccf4a42005-12-17 17:58:46 -0500288 } else { /* Skeleton QH */
289 qh->state = QH_STATE_ACTIVE;
Alan Stern4de7d2c2006-05-05 16:26:58 -0400290 qh->type = -1;
Alan Sterndccf4a42005-12-17 17:58:46 -0500291 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 return qh;
293}
294
295static void uhci_free_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
296{
Alan Sterndccf4a42005-12-17 17:58:46 -0500297 WARN_ON(qh->state != QH_STATE_IDLE && qh->udev);
Alan Stern0cef7722007-03-19 15:33:11 -0400298 if (!list_empty(&qh->queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 dev_warn(uhci_dev(uhci), "qh %p list not empty!\n", qh);
Alan Stern0cef7722007-03-19 15:33:11 -0400300 WARN_ON(1);
301 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
Alan Sterndccf4a42005-12-17 17:58:46 -0500303 list_del(&qh->node);
304 if (qh->udev) {
305 qh->hep->hcpriv = NULL;
Alan Stern85a975d2007-01-08 12:01:43 -0500306 if (qh->dummy_td)
307 uhci_free_td(uhci, qh->dummy_td);
Alan Sterndccf4a42005-12-17 17:58:46 -0500308 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 dma_pool_free(uhci->qh_pool, qh, qh->dma_handle);
310}
311
312/*
Alan Sterna0b458b2006-05-12 11:23:19 -0400313 * When a queue is stopped and a dequeued URB is given back, adjust
314 * the previous TD link (if the URB isn't first on the queue) or
315 * save its toggle value (if it is first and is currently executing).
Alan Stern10b8e472006-05-19 16:39:52 -0400316 *
317 * Returns 0 if the URB should not yet be given back, 1 otherwise.
Alan Stern0ed8fee2005-12-17 18:02:38 -0500318 */
Alan Stern10b8e472006-05-19 16:39:52 -0400319static int uhci_cleanup_queue(struct uhci_hcd *uhci, struct uhci_qh *qh,
Alan Sterna0b458b2006-05-12 11:23:19 -0400320 struct urb *urb)
Alan Stern0ed8fee2005-12-17 18:02:38 -0500321{
Alan Sterna0b458b2006-05-12 11:23:19 -0400322 struct urb_priv *urbp = urb->hcpriv;
Alan Stern0ed8fee2005-12-17 18:02:38 -0500323 struct uhci_td *td;
Alan Stern10b8e472006-05-19 16:39:52 -0400324 int ret = 1;
Alan Stern0ed8fee2005-12-17 18:02:38 -0500325
Alan Sterna0b458b2006-05-12 11:23:19 -0400326 /* Isochronous pipes don't use toggles and their TD link pointers
Alan Stern10b8e472006-05-19 16:39:52 -0400327 * get adjusted during uhci_urb_dequeue(). But since their queues
328 * cannot truly be stopped, we have to watch out for dequeues
329 * occurring after the nominal unlink frame. */
330 if (qh->type == USB_ENDPOINT_XFER_ISOC) {
331 ret = (uhci->frame_number + uhci->is_stopped !=
332 qh->unlink_frame);
Alan Sternc5e3b742006-06-05 12:28:57 -0400333 goto done;
Alan Stern10b8e472006-05-19 16:39:52 -0400334 }
Alan Sterna0b458b2006-05-12 11:23:19 -0400335
336 /* If the URB isn't first on its queue, adjust the link pointer
337 * of the last TD in the previous URB. The toggle doesn't need
338 * to be saved since this URB can't be executing yet. */
339 if (qh->queue.next != &urbp->node) {
340 struct urb_priv *purbp;
341 struct uhci_td *ptd;
342
343 purbp = list_entry(urbp->node.prev, struct urb_priv, node);
344 WARN_ON(list_empty(&purbp->td_list));
345 ptd = list_entry(purbp->td_list.prev, struct uhci_td,
346 list);
347 td = list_entry(urbp->td_list.prev, struct uhci_td,
348 list);
349 ptd->link = td->link;
Alan Sternc5e3b742006-06-05 12:28:57 -0400350 goto done;
Alan Sterna0b458b2006-05-12 11:23:19 -0400351 }
352
Alan Stern0ed8fee2005-12-17 18:02:38 -0500353 /* If the QH element pointer is UHCI_PTR_TERM then then currently
354 * executing URB has already been unlinked, so this one isn't it. */
Alan Sterna0b458b2006-05-12 11:23:19 -0400355 if (qh_element(qh) == UHCI_PTR_TERM)
Alan Sternc5e3b742006-06-05 12:28:57 -0400356 goto done;
Alan Stern0ed8fee2005-12-17 18:02:38 -0500357 qh->element = UHCI_PTR_TERM;
358
Alan Stern85a975d2007-01-08 12:01:43 -0500359 /* Control pipes don't have to worry about toggles */
Alan Sterna0b458b2006-05-12 11:23:19 -0400360 if (qh->type == USB_ENDPOINT_XFER_CONTROL)
Alan Sternc5e3b742006-06-05 12:28:57 -0400361 goto done;
Alan Stern0ed8fee2005-12-17 18:02:38 -0500362
Alan Sterna0b458b2006-05-12 11:23:19 -0400363 /* Save the next toggle value */
Alan Stern59e29ed2006-05-12 11:19:19 -0400364 WARN_ON(list_empty(&urbp->td_list));
365 td = list_entry(urbp->td_list.next, struct uhci_td, list);
366 qh->needs_fixup = 1;
367 qh->initial_toggle = uhci_toggle(td_token(td));
Alan Sternc5e3b742006-06-05 12:28:57 -0400368
369done:
Alan Stern10b8e472006-05-19 16:39:52 -0400370 return ret;
Alan Stern0ed8fee2005-12-17 18:02:38 -0500371}
372
373/*
374 * Fix up the data toggles for URBs in a queue, when one of them
375 * terminates early (short transfer, error, or dequeued).
376 */
377static void uhci_fixup_toggles(struct uhci_qh *qh, int skip_first)
378{
379 struct urb_priv *urbp = NULL;
380 struct uhci_td *td;
381 unsigned int toggle = qh->initial_toggle;
382 unsigned int pipe;
383
384 /* Fixups for a short transfer start with the second URB in the
385 * queue (the short URB is the first). */
386 if (skip_first)
387 urbp = list_entry(qh->queue.next, struct urb_priv, node);
388
389 /* When starting with the first URB, if the QH element pointer is
390 * still valid then we know the URB's toggles are okay. */
391 else if (qh_element(qh) != UHCI_PTR_TERM)
392 toggle = 2;
393
394 /* Fix up the toggle for the URBs in the queue. Normally this
395 * loop won't run more than once: When an error or short transfer
396 * occurs, the queue usually gets emptied. */
Alan Stern1393adb2006-01-31 10:02:55 -0500397 urbp = list_prepare_entry(urbp, &qh->queue, node);
Alan Stern0ed8fee2005-12-17 18:02:38 -0500398 list_for_each_entry_continue(urbp, &qh->queue, node) {
399
400 /* If the first TD has the right toggle value, we don't
401 * need to change any toggles in this URB */
402 td = list_entry(urbp->td_list.next, struct uhci_td, list);
403 if (toggle > 1 || uhci_toggle(td_token(td)) == toggle) {
Alan Sterndb59b462006-08-31 14:18:39 -0400404 td = list_entry(urbp->td_list.prev, struct uhci_td,
Alan Stern0ed8fee2005-12-17 18:02:38 -0500405 list);
406 toggle = uhci_toggle(td_token(td)) ^ 1;
407
408 /* Otherwise all the toggles in the URB have to be switched */
409 } else {
410 list_for_each_entry(td, &urbp->td_list, list) {
411 td->token ^= __constant_cpu_to_le32(
412 TD_TOKEN_TOGGLE);
413 toggle ^= 1;
414 }
415 }
416 }
417
418 wmb();
419 pipe = list_entry(qh->queue.next, struct urb_priv, node)->urb->pipe;
420 usb_settoggle(qh->udev, usb_pipeendpoint(pipe),
421 usb_pipeout(pipe), toggle);
422 qh->needs_fixup = 0;
423}
424
425/*
Alan Stern17230ac2007-02-19 15:52:45 -0500426 * Link an Isochronous QH into its skeleton's list
427 */
428static inline void link_iso(struct uhci_hcd *uhci, struct uhci_qh *qh)
429{
430 list_add_tail(&qh->node, &uhci->skel_iso_qh->node);
431
432 /* Isochronous QHs aren't linked by the hardware */
433}
434
435/*
436 * Link a high-period interrupt QH into the schedule at the end of its
437 * skeleton's list
438 */
439static void link_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh)
440{
441 struct uhci_qh *pqh;
442
443 list_add_tail(&qh->node, &uhci->skelqh[qh->skel]->node);
444
445 pqh = list_entry(qh->node.prev, struct uhci_qh, node);
446 qh->link = pqh->link;
447 wmb();
448 pqh->link = LINK_TO_QH(qh);
449}
450
451/*
452 * Link a period-1 interrupt or async QH into the schedule at the
453 * correct spot in the async skeleton's list, and update the FSBR link
454 */
455static void link_async(struct uhci_hcd *uhci, struct uhci_qh *qh)
456{
Alan Sterne009f1b2007-03-19 15:31:42 -0400457 struct uhci_qh *pqh;
Alan Stern17230ac2007-02-19 15:52:45 -0500458 __le32 link_to_new_qh;
Alan Stern17230ac2007-02-19 15:52:45 -0500459
460 /* Find the predecessor QH for our new one and insert it in the list.
461 * The list of QHs is expected to be short, so linear search won't
462 * take too long. */
463 list_for_each_entry_reverse(pqh, &uhci->skel_async_qh->node, node) {
464 if (pqh->skel <= qh->skel)
465 break;
466 }
467 list_add(&qh->node, &pqh->node);
Alan Stern17230ac2007-02-19 15:52:45 -0500468
469 /* Link it into the schedule */
Alan Sterne009f1b2007-03-19 15:31:42 -0400470 qh->link = pqh->link;
Alan Stern17230ac2007-02-19 15:52:45 -0500471 wmb();
Alan Sterne009f1b2007-03-19 15:31:42 -0400472 link_to_new_qh = LINK_TO_QH(qh);
473 pqh->link = link_to_new_qh;
474
475 /* If this is now the first FSBR QH, link the terminating skeleton
476 * QH to it. */
477 if (pqh->skel < SKEL_FSBR && qh->skel >= SKEL_FSBR)
478 uhci->skel_term_qh->link = link_to_new_qh;
Alan Stern17230ac2007-02-19 15:52:45 -0500479}
480
481/*
Alan Sterndccf4a42005-12-17 17:58:46 -0500482 * Put a QH on the schedule in both hardware and software
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 */
Alan Sterndccf4a42005-12-17 17:58:46 -0500484static void uhci_activate_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485{
Alan Sterndccf4a42005-12-17 17:58:46 -0500486 WARN_ON(list_empty(&qh->queue));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
Alan Sterndccf4a42005-12-17 17:58:46 -0500488 /* Set the element pointer if it isn't set already.
489 * This isn't needed for Isochronous queues, but it doesn't hurt. */
490 if (qh_element(qh) == UHCI_PTR_TERM) {
491 struct urb_priv *urbp = list_entry(qh->queue.next,
492 struct urb_priv, node);
493 struct uhci_td *td = list_entry(urbp->td_list.next,
494 struct uhci_td, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
Alan Stern28b93252007-02-19 15:51:51 -0500496 qh->element = LINK_TO_TD(td);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 }
498
Alan Stern84afddd2006-05-12 11:35:45 -0400499 /* Treat the queue as if it has just advanced */
500 qh->wait_expired = 0;
501 qh->advance_jiffies = jiffies;
502
Alan Sterndccf4a42005-12-17 17:58:46 -0500503 if (qh->state == QH_STATE_ACTIVE)
504 return;
505 qh->state = QH_STATE_ACTIVE;
506
Alan Stern17230ac2007-02-19 15:52:45 -0500507 /* Move the QH from its old list to the correct spot in the appropriate
Alan Sterndccf4a42005-12-17 17:58:46 -0500508 * skeleton's list */
Alan Stern0ed8fee2005-12-17 18:02:38 -0500509 if (qh == uhci->next_qh)
510 uhci->next_qh = list_entry(qh->node.next, struct uhci_qh,
511 node);
Alan Stern17230ac2007-02-19 15:52:45 -0500512 list_del(&qh->node);
Alan Sterndccf4a42005-12-17 17:58:46 -0500513
Alan Stern17230ac2007-02-19 15:52:45 -0500514 if (qh->skel == SKEL_ISO)
515 link_iso(uhci, qh);
516 else if (qh->skel < SKEL_ASYNC)
517 link_interrupt(uhci, qh);
518 else
519 link_async(uhci, qh);
520}
521
522/*
523 * Unlink a high-period interrupt QH from the schedule
524 */
525static void unlink_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh)
526{
527 struct uhci_qh *pqh;
528
Alan Sterndccf4a42005-12-17 17:58:46 -0500529 pqh = list_entry(qh->node.prev, struct uhci_qh, node);
Alan Stern17230ac2007-02-19 15:52:45 -0500530 pqh->link = qh->link;
531 mb();
532}
533
534/*
535 * Unlink a period-1 interrupt or async QH from the schedule
536 */
537static void unlink_async(struct uhci_hcd *uhci, struct uhci_qh *qh)
538{
Alan Sterne009f1b2007-03-19 15:31:42 -0400539 struct uhci_qh *pqh;
Alan Stern17230ac2007-02-19 15:52:45 -0500540 __le32 link_to_next_qh = qh->link;
541
542 pqh = list_entry(qh->node.prev, struct uhci_qh, node);
Alan Stern17230ac2007-02-19 15:52:45 -0500543 pqh->link = link_to_next_qh;
Alan Sterne009f1b2007-03-19 15:31:42 -0400544
545 /* If this was the old first FSBR QH, link the terminating skeleton
546 * QH to the next (new first FSBR) QH. */
547 if (pqh->skel < SKEL_FSBR && qh->skel >= SKEL_FSBR)
548 uhci->skel_term_qh->link = link_to_next_qh;
Alan Stern17230ac2007-02-19 15:52:45 -0500549 mb();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550}
551
552/*
Alan Sterndccf4a42005-12-17 17:58:46 -0500553 * Take a QH off the hardware schedule
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 */
Alan Sterndccf4a42005-12-17 17:58:46 -0500555static void uhci_unlink_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556{
Alan Sterndccf4a42005-12-17 17:58:46 -0500557 if (qh->state == QH_STATE_UNLINKING)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 return;
Alan Sterndccf4a42005-12-17 17:58:46 -0500559 WARN_ON(qh->state != QH_STATE_ACTIVE || !qh->udev);
560 qh->state = QH_STATE_UNLINKING;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
Alan Sterndccf4a42005-12-17 17:58:46 -0500562 /* Unlink the QH from the schedule and record when we did it */
Alan Stern17230ac2007-02-19 15:52:45 -0500563 if (qh->skel == SKEL_ISO)
564 ;
565 else if (qh->skel < SKEL_ASYNC)
566 unlink_interrupt(uhci, qh);
567 else
568 unlink_async(uhci, qh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570 uhci_get_current_frame_number(uhci);
Alan Sterndccf4a42005-12-17 17:58:46 -0500571 qh->unlink_frame = uhci->frame_number;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
Alan Sterndccf4a42005-12-17 17:58:46 -0500573 /* Force an interrupt so we know when the QH is fully unlinked */
574 if (list_empty(&uhci->skel_unlink_qh->node))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 uhci_set_next_interrupt(uhci);
576
Alan Sterndccf4a42005-12-17 17:58:46 -0500577 /* Move the QH from its old list to the end of the unlinking list */
Alan Stern0ed8fee2005-12-17 18:02:38 -0500578 if (qh == uhci->next_qh)
579 uhci->next_qh = list_entry(qh->node.next, struct uhci_qh,
580 node);
Alan Sterndccf4a42005-12-17 17:58:46 -0500581 list_move_tail(&qh->node, &uhci->skel_unlink_qh->node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582}
583
Alan Sterndccf4a42005-12-17 17:58:46 -0500584/*
585 * When we and the controller are through with a QH, it becomes IDLE.
586 * This happens when a QH has been off the schedule (on the unlinking
587 * list) for more than one frame, or when an error occurs while adding
588 * the first URB onto a new QH.
589 */
590static void uhci_make_qh_idle(struct uhci_hcd *uhci, struct uhci_qh *qh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591{
Alan Sterndccf4a42005-12-17 17:58:46 -0500592 WARN_ON(qh->state == QH_STATE_ACTIVE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593
Alan Stern0ed8fee2005-12-17 18:02:38 -0500594 if (qh == uhci->next_qh)
595 uhci->next_qh = list_entry(qh->node.next, struct uhci_qh,
596 node);
Alan Sterndccf4a42005-12-17 17:58:46 -0500597 list_move(&qh->node, &uhci->idle_qh_list);
598 qh->state = QH_STATE_IDLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
Alan Stern59e29ed2006-05-12 11:19:19 -0400600 /* Now that the QH is idle, its post_td isn't being used */
601 if (qh->post_td) {
602 uhci_free_td(uhci, qh->post_td);
603 qh->post_td = NULL;
604 }
605
Alan Sterndccf4a42005-12-17 17:58:46 -0500606 /* If anyone is waiting for a QH to become idle, wake them up */
607 if (uhci->num_waiting)
608 wake_up_all(&uhci->waitqh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609}
610
Alan Stern3ca2a322007-01-16 11:56:32 -0500611/*
612 * Find the highest existing bandwidth load for a given phase and period.
613 */
614static int uhci_highest_load(struct uhci_hcd *uhci, int phase, int period)
615{
616 int highest_load = uhci->load[phase];
617
618 for (phase += period; phase < MAX_PHASE; phase += period)
619 highest_load = max_t(int, highest_load, uhci->load[phase]);
620 return highest_load;
621}
622
623/*
624 * Set qh->phase to the optimal phase for a periodic transfer and
625 * check whether the bandwidth requirement is acceptable.
626 */
627static int uhci_check_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh)
628{
629 int minimax_load;
630
631 /* Find the optimal phase (unless it is already set) and get
632 * its load value. */
633 if (qh->phase >= 0)
634 minimax_load = uhci_highest_load(uhci, qh->phase, qh->period);
635 else {
636 int phase, load;
637 int max_phase = min_t(int, MAX_PHASE, qh->period);
638
639 qh->phase = 0;
640 minimax_load = uhci_highest_load(uhci, qh->phase, qh->period);
641 for (phase = 1; phase < max_phase; ++phase) {
642 load = uhci_highest_load(uhci, phase, qh->period);
643 if (load < minimax_load) {
644 minimax_load = load;
645 qh->phase = phase;
646 }
647 }
648 }
649
650 /* Maximum allowable periodic bandwidth is 90%, or 900 us per frame */
651 if (minimax_load + qh->load > 900) {
652 dev_dbg(uhci_dev(uhci), "bandwidth allocation failed: "
653 "period %d, phase %d, %d + %d us\n",
654 qh->period, qh->phase, minimax_load, qh->load);
655 return -ENOSPC;
656 }
657 return 0;
658}
659
660/*
661 * Reserve a periodic QH's bandwidth in the schedule
662 */
663static void uhci_reserve_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh)
664{
665 int i;
666 int load = qh->load;
667 char *p = "??";
668
669 for (i = qh->phase; i < MAX_PHASE; i += qh->period) {
670 uhci->load[i] += load;
671 uhci->total_load += load;
672 }
673 uhci_to_hcd(uhci)->self.bandwidth_allocated =
674 uhci->total_load / MAX_PHASE;
675 switch (qh->type) {
676 case USB_ENDPOINT_XFER_INT:
677 ++uhci_to_hcd(uhci)->self.bandwidth_int_reqs;
678 p = "INT";
679 break;
680 case USB_ENDPOINT_XFER_ISOC:
681 ++uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs;
682 p = "ISO";
683 break;
684 }
685 qh->bandwidth_reserved = 1;
686 dev_dbg(uhci_dev(uhci),
687 "%s dev %d ep%02x-%s, period %d, phase %d, %d us\n",
688 "reserve", qh->udev->devnum,
689 qh->hep->desc.bEndpointAddress, p,
690 qh->period, qh->phase, load);
691}
692
693/*
694 * Release a periodic QH's bandwidth reservation
695 */
696static void uhci_release_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh)
697{
698 int i;
699 int load = qh->load;
700 char *p = "??";
701
702 for (i = qh->phase; i < MAX_PHASE; i += qh->period) {
703 uhci->load[i] -= load;
704 uhci->total_load -= load;
705 }
706 uhci_to_hcd(uhci)->self.bandwidth_allocated =
707 uhci->total_load / MAX_PHASE;
708 switch (qh->type) {
709 case USB_ENDPOINT_XFER_INT:
710 --uhci_to_hcd(uhci)->self.bandwidth_int_reqs;
711 p = "INT";
712 break;
713 case USB_ENDPOINT_XFER_ISOC:
714 --uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs;
715 p = "ISO";
716 break;
717 }
718 qh->bandwidth_reserved = 0;
719 dev_dbg(uhci_dev(uhci),
720 "%s dev %d ep%02x-%s, period %d, phase %d, %d us\n",
721 "release", qh->udev->devnum,
722 qh->hep->desc.bEndpointAddress, p,
723 qh->period, qh->phase, load);
724}
725
Alan Sterndccf4a42005-12-17 17:58:46 -0500726static inline struct urb_priv *uhci_alloc_urb_priv(struct uhci_hcd *uhci,
727 struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728{
729 struct urb_priv *urbp;
730
Robert P. J. Dayc3762222007-02-10 01:45:03 -0800731 urbp = kmem_cache_zalloc(uhci_up_cachep, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 if (!urbp)
733 return NULL;
734
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 urbp->urb = urb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 urb->hcpriv = urbp;
Alan Sterndccf4a42005-12-17 17:58:46 -0500737
738 INIT_LIST_HEAD(&urbp->node);
739 INIT_LIST_HEAD(&urbp->td_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
741 return urbp;
742}
743
Alan Sterndccf4a42005-12-17 17:58:46 -0500744static void uhci_free_urb_priv(struct uhci_hcd *uhci,
745 struct urb_priv *urbp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746{
747 struct uhci_td *td, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
Alan Stern0cef7722007-03-19 15:33:11 -0400749 if (!list_empty(&urbp->node)) {
Alan Sterndccf4a42005-12-17 17:58:46 -0500750 dev_warn(uhci_dev(uhci), "urb %p still on QH's list!\n",
751 urbp->urb);
Alan Stern0cef7722007-03-19 15:33:11 -0400752 WARN_ON(1);
753 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 list_for_each_entry_safe(td, tmp, &urbp->td_list, list) {
Alan Stern04538a22006-05-12 11:29:04 -0400756 uhci_remove_td_from_urbp(td);
757 uhci_free_td(uhci, td);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 }
759
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 kmem_cache_free(uhci_up_cachep, urbp);
761}
762
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763/*
764 * Map status to standard result codes
765 *
766 * <status> is (td_status(td) & 0xF60000), a.k.a.
767 * uhci_status_bits(td_status(td)).
768 * Note: <status> does not include the TD_CTRL_NAK bit.
769 * <dir_out> is True for output TDs and False for input TDs.
770 */
771static int uhci_map_status(int status, int dir_out)
772{
773 if (!status)
774 return 0;
775 if (status & TD_CTRL_BITSTUFF) /* Bitstuff error */
776 return -EPROTO;
777 if (status & TD_CTRL_CRCTIMEO) { /* CRC/Timeout */
778 if (dir_out)
779 return -EPROTO;
780 else
781 return -EILSEQ;
782 }
783 if (status & TD_CTRL_BABBLE) /* Babble */
784 return -EOVERFLOW;
785 if (status & TD_CTRL_DBUFERR) /* Buffer error */
786 return -ENOSR;
787 if (status & TD_CTRL_STALLED) /* Stalled */
788 return -EPIPE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 return 0;
790}
791
792/*
793 * Control transfers
794 */
Alan Sterndccf4a42005-12-17 17:58:46 -0500795static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
796 struct uhci_qh *qh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 struct uhci_td *td;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 unsigned long destination, status;
Alan Sterndccf4a42005-12-17 17:58:46 -0500800 int maxsze = le16_to_cpu(qh->hep->desc.wMaxPacketSize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 int len = urb->transfer_buffer_length;
802 dma_addr_t data = urb->transfer_dma;
Alan Sterndccf4a42005-12-17 17:58:46 -0500803 __le32 *plink;
Alan Stern04538a22006-05-12 11:29:04 -0400804 struct urb_priv *urbp = urb->hcpriv;
Alan Stern17230ac2007-02-19 15:52:45 -0500805 int skel;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
807 /* The "pipe" thing contains the destination in bits 8--18 */
808 destination = (urb->pipe & PIPE_DEVEP_MASK) | USB_PID_SETUP;
809
Alan Sternaf0bb592005-12-17 18:00:12 -0500810 /* 3 errors, dummy TD remains inactive */
811 status = uhci_maxerr(3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 if (urb->dev->speed == USB_SPEED_LOW)
813 status |= TD_CTRL_LS;
814
815 /*
816 * Build the TD for the control request setup packet
817 */
Alan Sternaf0bb592005-12-17 18:00:12 -0500818 td = qh->dummy_td;
Alan Stern04538a22006-05-12 11:29:04 -0400819 uhci_add_td_to_urbp(td, urbp);
Alan Sternfa346562005-11-30 11:57:51 -0500820 uhci_fill_td(td, status, destination | uhci_explen(8),
Alan Sterndccf4a42005-12-17 17:58:46 -0500821 urb->setup_dma);
822 plink = &td->link;
Alan Sternaf0bb592005-12-17 18:00:12 -0500823 status |= TD_CTRL_ACTIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825 /*
826 * If direction is "send", change the packet ID from SETUP (0x2D)
827 * to OUT (0xE1). Else change it from SETUP to IN (0x69) and
828 * set Short Packet Detect (SPD) for all data packets.
Alan Sterne7e7c362007-07-13 15:46:29 -0400829 *
830 * 0-length transfers always get treated as "send".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 */
Alan Sterne7e7c362007-07-13 15:46:29 -0400832 if (usb_pipeout(urb->pipe) || len == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 destination ^= (USB_PID_SETUP ^ USB_PID_OUT);
834 else {
835 destination ^= (USB_PID_SETUP ^ USB_PID_IN);
836 status |= TD_CTRL_SPD;
837 }
838
839 /*
Alan Stern687f5f32005-11-30 17:16:19 -0500840 * Build the DATA TDs
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 */
842 while (len > 0) {
Alan Sterne7e7c362007-07-13 15:46:29 -0400843 int pktsze = maxsze;
844
845 if (len <= pktsze) { /* The last data packet */
846 pktsze = len;
847 status &= ~TD_CTRL_SPD;
848 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849
Alan Stern25321782005-04-25 11:14:31 -0400850 td = uhci_alloc_td(uhci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 if (!td)
Alan Sternaf0bb592005-12-17 18:00:12 -0500852 goto nomem;
Alan Stern28b93252007-02-19 15:51:51 -0500853 *plink = LINK_TO_TD(td);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854
855 /* Alternate Data0/1 (start with Data1) */
856 destination ^= TD_TOKEN_TOGGLE;
857
Alan Stern04538a22006-05-12 11:29:04 -0400858 uhci_add_td_to_urbp(td, urbp);
Alan Sternfa346562005-11-30 11:57:51 -0500859 uhci_fill_td(td, status, destination | uhci_explen(pktsze),
Alan Sterndccf4a42005-12-17 17:58:46 -0500860 data);
861 plink = &td->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
863 data += pktsze;
864 len -= pktsze;
865 }
866
867 /*
868 * Build the final TD for control status
869 */
Alan Stern25321782005-04-25 11:14:31 -0400870 td = uhci_alloc_td(uhci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 if (!td)
Alan Sternaf0bb592005-12-17 18:00:12 -0500872 goto nomem;
Alan Stern28b93252007-02-19 15:51:51 -0500873 *plink = LINK_TO_TD(td);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
Alan Sterne7e7c362007-07-13 15:46:29 -0400875 /* Change direction for the status transaction */
876 destination ^= (USB_PID_IN ^ USB_PID_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 destination |= TD_TOKEN_TOGGLE; /* End in Data1 */
878
Alan Stern04538a22006-05-12 11:29:04 -0400879 uhci_add_td_to_urbp(td, urbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 uhci_fill_td(td, status | TD_CTRL_IOC,
Alan Sterndccf4a42005-12-17 17:58:46 -0500881 destination | uhci_explen(0), 0);
Alan Sternaf0bb592005-12-17 18:00:12 -0500882 plink = &td->link;
883
884 /*
885 * Build the new dummy TD and activate the old one
886 */
887 td = uhci_alloc_td(uhci);
888 if (!td)
889 goto nomem;
Alan Stern28b93252007-02-19 15:51:51 -0500890 *plink = LINK_TO_TD(td);
Alan Sternaf0bb592005-12-17 18:00:12 -0500891
892 uhci_fill_td(td, 0, USB_PID_OUT | uhci_explen(0), 0);
893 wmb();
894 qh->dummy_td->status |= __constant_cpu_to_le32(TD_CTRL_ACTIVE);
895 qh->dummy_td = td;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
897 /* Low-speed transfers get a different queue, and won't hog the bus.
898 * Also, some devices enumerate better without FSBR; the easiest way
899 * to do that is to put URBs on the low-speed queue while the device
Alan Stern630aa3c2006-01-23 17:17:21 -0500900 * isn't in the CONFIGURED state. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 if (urb->dev->speed == USB_SPEED_LOW ||
Alan Stern630aa3c2006-01-23 17:17:21 -0500902 urb->dev->state != USB_STATE_CONFIGURED)
Alan Stern17230ac2007-02-19 15:52:45 -0500903 skel = SKEL_LS_CONTROL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 else {
Alan Stern17230ac2007-02-19 15:52:45 -0500905 skel = SKEL_FS_CONTROL;
Alan Stern84afddd2006-05-12 11:35:45 -0400906 uhci_add_fsbr(uhci, urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 }
Alan Stern17230ac2007-02-19 15:52:45 -0500908 if (qh->state != QH_STATE_ACTIVE)
909 qh->skel = skel;
Alan Stern59e29ed2006-05-12 11:19:19 -0400910
911 urb->actual_length = -8; /* Account for the SETUP packet */
Alan Sterndccf4a42005-12-17 17:58:46 -0500912 return 0;
Alan Sternaf0bb592005-12-17 18:00:12 -0500913
914nomem:
915 /* Remove the dummy TD from the td_list so it doesn't get freed */
Alan Stern04538a22006-05-12 11:29:04 -0400916 uhci_remove_td_from_urbp(qh->dummy_td);
Alan Sternaf0bb592005-12-17 18:00:12 -0500917 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918}
919
920/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 * Common submit for bulk and interrupt
922 */
Alan Sterndccf4a42005-12-17 17:58:46 -0500923static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
924 struct uhci_qh *qh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925{
926 struct uhci_td *td;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 unsigned long destination, status;
Alan Sterndccf4a42005-12-17 17:58:46 -0500928 int maxsze = le16_to_cpu(qh->hep->desc.wMaxPacketSize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 int len = urb->transfer_buffer_length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 dma_addr_t data = urb->transfer_dma;
Alan Sternaf0bb592005-12-17 18:00:12 -0500931 __le32 *plink;
Alan Stern04538a22006-05-12 11:29:04 -0400932 struct urb_priv *urbp = urb->hcpriv;
Alan Sternaf0bb592005-12-17 18:00:12 -0500933 unsigned int toggle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
935 if (len < 0)
936 return -EINVAL;
937
938 /* The "pipe" thing contains the destination in bits 8--18 */
939 destination = (urb->pipe & PIPE_DEVEP_MASK) | usb_packetid(urb->pipe);
Alan Sternaf0bb592005-12-17 18:00:12 -0500940 toggle = usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe),
941 usb_pipeout(urb->pipe));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942
Alan Sternaf0bb592005-12-17 18:00:12 -0500943 /* 3 errors, dummy TD remains inactive */
944 status = uhci_maxerr(3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 if (urb->dev->speed == USB_SPEED_LOW)
946 status |= TD_CTRL_LS;
947 if (usb_pipein(urb->pipe))
948 status |= TD_CTRL_SPD;
949
950 /*
Alan Stern687f5f32005-11-30 17:16:19 -0500951 * Build the DATA TDs
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 */
Alan Sternaf0bb592005-12-17 18:00:12 -0500953 plink = NULL;
954 td = qh->dummy_td;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 do { /* Allow zero length packets */
956 int pktsze = maxsze;
957
Alan Sterndccf4a42005-12-17 17:58:46 -0500958 if (len <= pktsze) { /* The last packet */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 pktsze = len;
960 if (!(urb->transfer_flags & URB_SHORT_NOT_OK))
961 status &= ~TD_CTRL_SPD;
962 }
963
Alan Sternaf0bb592005-12-17 18:00:12 -0500964 if (plink) {
965 td = uhci_alloc_td(uhci);
966 if (!td)
967 goto nomem;
Alan Stern28b93252007-02-19 15:51:51 -0500968 *plink = LINK_TO_TD(td);
Alan Sternaf0bb592005-12-17 18:00:12 -0500969 }
Alan Stern04538a22006-05-12 11:29:04 -0400970 uhci_add_td_to_urbp(td, urbp);
Alan Sterndccf4a42005-12-17 17:58:46 -0500971 uhci_fill_td(td, status,
Alan Sternaf0bb592005-12-17 18:00:12 -0500972 destination | uhci_explen(pktsze) |
973 (toggle << TD_TOKEN_TOGGLE_SHIFT),
974 data);
Alan Sterndccf4a42005-12-17 17:58:46 -0500975 plink = &td->link;
Alan Sternaf0bb592005-12-17 18:00:12 -0500976 status |= TD_CTRL_ACTIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977
978 data += pktsze;
979 len -= maxsze;
Alan Sternaf0bb592005-12-17 18:00:12 -0500980 toggle ^= 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 } while (len > 0);
982
983 /*
984 * URB_ZERO_PACKET means adding a 0-length packet, if direction
985 * is OUT and the transfer_length was an exact multiple of maxsze,
986 * hence (len = transfer_length - N * maxsze) == 0
987 * however, if transfer_length == 0, the zero packet was already
988 * prepared above.
989 */
Alan Sterndccf4a42005-12-17 17:58:46 -0500990 if ((urb->transfer_flags & URB_ZERO_PACKET) &&
991 usb_pipeout(urb->pipe) && len == 0 &&
992 urb->transfer_buffer_length > 0) {
Alan Stern25321782005-04-25 11:14:31 -0400993 td = uhci_alloc_td(uhci);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 if (!td)
Alan Sternaf0bb592005-12-17 18:00:12 -0500995 goto nomem;
Alan Stern28b93252007-02-19 15:51:51 -0500996 *plink = LINK_TO_TD(td);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997
Alan Stern04538a22006-05-12 11:29:04 -0400998 uhci_add_td_to_urbp(td, urbp);
Alan Sternaf0bb592005-12-17 18:00:12 -0500999 uhci_fill_td(td, status,
1000 destination | uhci_explen(0) |
1001 (toggle << TD_TOKEN_TOGGLE_SHIFT),
1002 data);
1003 plink = &td->link;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004
Alan Sternaf0bb592005-12-17 18:00:12 -05001005 toggle ^= 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 }
1007
1008 /* Set the interrupt-on-completion flag on the last packet.
1009 * A more-or-less typical 4 KB URB (= size of one memory page)
1010 * will require about 3 ms to transfer; that's a little on the
1011 * fast side but not enough to justify delaying an interrupt
1012 * more than 2 or 3 URBs, so we will ignore the URB_NO_INTERRUPT
1013 * flag setting. */
Alan Sterndccf4a42005-12-17 17:58:46 -05001014 td->status |= __constant_cpu_to_le32(TD_CTRL_IOC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
Alan Sternaf0bb592005-12-17 18:00:12 -05001016 /*
1017 * Build the new dummy TD and activate the old one
1018 */
1019 td = uhci_alloc_td(uhci);
1020 if (!td)
1021 goto nomem;
Alan Stern28b93252007-02-19 15:51:51 -05001022 *plink = LINK_TO_TD(td);
Alan Sternaf0bb592005-12-17 18:00:12 -05001023
1024 uhci_fill_td(td, 0, USB_PID_OUT | uhci_explen(0), 0);
1025 wmb();
1026 qh->dummy_td->status |= __constant_cpu_to_le32(TD_CTRL_ACTIVE);
1027 qh->dummy_td = td;
1028
1029 usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
1030 usb_pipeout(urb->pipe), toggle);
Alan Sterndccf4a42005-12-17 17:58:46 -05001031 return 0;
Alan Sternaf0bb592005-12-17 18:00:12 -05001032
1033nomem:
1034 /* Remove the dummy TD from the td_list so it doesn't get freed */
Alan Stern04538a22006-05-12 11:29:04 -04001035 uhci_remove_td_from_urbp(qh->dummy_td);
Alan Sternaf0bb592005-12-17 18:00:12 -05001036 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037}
1038
Alan Stern17230ac2007-02-19 15:52:45 -05001039static int uhci_submit_bulk(struct uhci_hcd *uhci, struct urb *urb,
Alan Sterndccf4a42005-12-17 17:58:46 -05001040 struct uhci_qh *qh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041{
1042 int ret;
1043
1044 /* Can't have low-speed bulk transfers */
1045 if (urb->dev->speed == USB_SPEED_LOW)
1046 return -EINVAL;
1047
Alan Stern17230ac2007-02-19 15:52:45 -05001048 if (qh->state != QH_STATE_ACTIVE)
1049 qh->skel = SKEL_BULK;
Alan Sterndccf4a42005-12-17 17:58:46 -05001050 ret = uhci_submit_common(uhci, urb, qh);
1051 if (ret == 0)
Alan Stern84afddd2006-05-12 11:35:45 -04001052 uhci_add_fsbr(uhci, urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 return ret;
1054}
1055
Alan Sterncaf38272006-05-19 16:44:55 -04001056static int uhci_submit_interrupt(struct uhci_hcd *uhci, struct urb *urb,
Alan Sterndccf4a42005-12-17 17:58:46 -05001057 struct uhci_qh *qh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058{
Alan Stern3ca2a322007-01-16 11:56:32 -05001059 int ret;
Alan Sterncaf38272006-05-19 16:44:55 -04001060
Alan Sterndccf4a42005-12-17 17:58:46 -05001061 /* USB 1.1 interrupt transfers only involve one packet per interval.
1062 * Drivers can submit URBs of any length, but longer ones will need
1063 * multiple intervals to complete.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 */
Alan Sterncaf38272006-05-19 16:44:55 -04001065
Alan Stern3ca2a322007-01-16 11:56:32 -05001066 if (!qh->bandwidth_reserved) {
1067 int exponent;
Alan Sterncaf38272006-05-19 16:44:55 -04001068
Alan Stern3ca2a322007-01-16 11:56:32 -05001069 /* Figure out which power-of-two queue to use */
1070 for (exponent = 7; exponent >= 0; --exponent) {
1071 if ((1 << exponent) <= urb->interval)
1072 break;
1073 }
1074 if (exponent < 0)
1075 return -EINVAL;
1076 qh->period = 1 << exponent;
Alan Stern17230ac2007-02-19 15:52:45 -05001077 qh->skel = SKEL_INDEX(exponent);
Alan Sterncaf38272006-05-19 16:44:55 -04001078
Alan Stern3ca2a322007-01-16 11:56:32 -05001079 /* For now, interrupt phase is fixed by the layout
1080 * of the QH lists. */
1081 qh->phase = (qh->period / 2) & (MAX_PHASE - 1);
1082 ret = uhci_check_bandwidth(uhci, qh);
1083 if (ret)
1084 return ret;
1085 } else if (qh->period > urb->interval)
1086 return -EINVAL; /* Can't decrease the period */
1087
1088 ret = uhci_submit_common(uhci, urb, qh);
1089 if (ret == 0) {
1090 urb->interval = qh->period;
1091 if (!qh->bandwidth_reserved)
1092 uhci_reserve_bandwidth(uhci, qh);
1093 }
1094 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095}
1096
1097/*
Alan Sternb1869002006-05-12 11:14:25 -04001098 * Fix up the data structures following a short transfer
1099 */
1100static int uhci_fixup_short_transfer(struct uhci_hcd *uhci,
Alan Stern59e29ed2006-05-12 11:19:19 -04001101 struct uhci_qh *qh, struct urb_priv *urbp)
Alan Sternb1869002006-05-12 11:14:25 -04001102{
1103 struct uhci_td *td;
Alan Stern59e29ed2006-05-12 11:19:19 -04001104 struct list_head *tmp;
1105 int ret;
Alan Sternb1869002006-05-12 11:14:25 -04001106
1107 td = list_entry(urbp->td_list.prev, struct uhci_td, list);
1108 if (qh->type == USB_ENDPOINT_XFER_CONTROL) {
Alan Sternb1869002006-05-12 11:14:25 -04001109
1110 /* When a control transfer is short, we have to restart
1111 * the queue at the status stage transaction, which is
1112 * the last TD. */
Alan Stern59e29ed2006-05-12 11:19:19 -04001113 WARN_ON(list_empty(&urbp->td_list));
Alan Stern28b93252007-02-19 15:51:51 -05001114 qh->element = LINK_TO_TD(td);
Alan Stern59e29ed2006-05-12 11:19:19 -04001115 tmp = td->list.prev;
Alan Sternb1869002006-05-12 11:14:25 -04001116 ret = -EINPROGRESS;
1117
Alan Stern59e29ed2006-05-12 11:19:19 -04001118 } else {
Alan Sternb1869002006-05-12 11:14:25 -04001119
1120 /* When a bulk/interrupt transfer is short, we have to
1121 * fix up the toggles of the following URBs on the queue
1122 * before restarting the queue at the next URB. */
Alan Stern59e29ed2006-05-12 11:19:19 -04001123 qh->initial_toggle = uhci_toggle(td_token(qh->post_td)) ^ 1;
Alan Sternb1869002006-05-12 11:14:25 -04001124 uhci_fixup_toggles(qh, 1);
1125
Alan Stern59e29ed2006-05-12 11:19:19 -04001126 if (list_empty(&urbp->td_list))
1127 td = qh->post_td;
Alan Sternb1869002006-05-12 11:14:25 -04001128 qh->element = td->link;
Alan Stern59e29ed2006-05-12 11:19:19 -04001129 tmp = urbp->td_list.prev;
1130 ret = 0;
Alan Sternb1869002006-05-12 11:14:25 -04001131 }
1132
Alan Stern59e29ed2006-05-12 11:19:19 -04001133 /* Remove all the TDs we skipped over, from tmp back to the start */
1134 while (tmp != &urbp->td_list) {
1135 td = list_entry(tmp, struct uhci_td, list);
1136 tmp = tmp->prev;
1137
Alan Stern04538a22006-05-12 11:29:04 -04001138 uhci_remove_td_from_urbp(td);
1139 uhci_free_td(uhci, td);
Alan Stern59e29ed2006-05-12 11:19:19 -04001140 }
Alan Sternb1869002006-05-12 11:14:25 -04001141 return ret;
1142}
1143
1144/*
1145 * Common result for control, bulk, and interrupt
1146 */
1147static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb)
1148{
1149 struct urb_priv *urbp = urb->hcpriv;
1150 struct uhci_qh *qh = urbp->qh;
Alan Stern59e29ed2006-05-12 11:19:19 -04001151 struct uhci_td *td, *tmp;
Alan Sternb1869002006-05-12 11:14:25 -04001152 unsigned status;
1153 int ret = 0;
1154
Alan Stern59e29ed2006-05-12 11:19:19 -04001155 list_for_each_entry_safe(td, tmp, &urbp->td_list, list) {
Alan Sternb1869002006-05-12 11:14:25 -04001156 unsigned int ctrlstat;
1157 int len;
1158
Alan Sternb1869002006-05-12 11:14:25 -04001159 ctrlstat = td_status(td);
1160 status = uhci_status_bits(ctrlstat);
1161 if (status & TD_CTRL_ACTIVE)
1162 return -EINPROGRESS;
1163
1164 len = uhci_actual_length(ctrlstat);
1165 urb->actual_length += len;
1166
1167 if (status) {
1168 ret = uhci_map_status(status,
1169 uhci_packetout(td_token(td)));
1170 if ((debug == 1 && ret != -EPIPE) || debug > 1) {
1171 /* Some debugging code */
David Brownellbe3cbc52006-06-05 12:16:39 -04001172 dev_dbg(&urb->dev->dev,
Alan Sternb1869002006-05-12 11:14:25 -04001173 "%s: failed with status %x\n",
1174 __FUNCTION__, status);
1175
1176 if (debug > 1 && errbuf) {
1177 /* Print the chain for debugging */
Alan Sterne009f1b2007-03-19 15:31:42 -04001178 uhci_show_qh(uhci, urbp->qh, errbuf,
Alan Sternb1869002006-05-12 11:14:25 -04001179 ERRBUF_LEN, 0);
1180 lprintk(errbuf);
1181 }
1182 }
1183
Alan Sterne7e7c362007-07-13 15:46:29 -04001184 /* Did we receive a short packet? */
Alan Sternb1869002006-05-12 11:14:25 -04001185 } else if (len < uhci_expected_length(td_token(td))) {
1186
Alan Sterne7e7c362007-07-13 15:46:29 -04001187 /* For control transfers, go to the status TD if
1188 * this isn't already the last data TD */
1189 if (qh->type == USB_ENDPOINT_XFER_CONTROL) {
1190 if (td->list.next != urbp->td_list.prev)
1191 ret = 1;
1192 }
1193
1194 /* For bulk and interrupt, this may be an error */
1195 else if (urb->transfer_flags & URB_SHORT_NOT_OK)
Alan Sternb1869002006-05-12 11:14:25 -04001196 ret = -EREMOTEIO;
Alan Sternf443ddf2006-07-31 10:16:24 -04001197
1198 /* Fixup needed only if this isn't the URB's last TD */
1199 else if (&td->list != urbp->td_list.prev)
Alan Sternb1869002006-05-12 11:14:25 -04001200 ret = 1;
1201 }
1202
Alan Stern04538a22006-05-12 11:29:04 -04001203 uhci_remove_td_from_urbp(td);
Alan Stern59e29ed2006-05-12 11:19:19 -04001204 if (qh->post_td)
Alan Stern04538a22006-05-12 11:29:04 -04001205 uhci_free_td(uhci, qh->post_td);
Alan Stern59e29ed2006-05-12 11:19:19 -04001206 qh->post_td = td;
1207
Alan Sternb1869002006-05-12 11:14:25 -04001208 if (ret != 0)
1209 goto err;
1210 }
1211 return ret;
1212
1213err:
1214 if (ret < 0) {
Alan Sternb1869002006-05-12 11:14:25 -04001215 /* Note that the queue has stopped and save
1216 * the next toggle value */
1217 qh->element = UHCI_PTR_TERM;
1218 qh->is_stopped = 1;
1219 qh->needs_fixup = (qh->type != USB_ENDPOINT_XFER_CONTROL);
1220 qh->initial_toggle = uhci_toggle(td_token(td)) ^
1221 (ret == -EREMOTEIO);
1222
1223 } else /* Short packet received */
Alan Stern59e29ed2006-05-12 11:19:19 -04001224 ret = uhci_fixup_short_transfer(uhci, qh, urbp);
Alan Sternb1869002006-05-12 11:14:25 -04001225 return ret;
1226}
1227
1228/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 * Isochronous transfers
1230 */
Alan Sterndccf4a42005-12-17 17:58:46 -05001231static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb,
1232 struct uhci_qh *qh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233{
Alan Sterndccf4a42005-12-17 17:58:46 -05001234 struct uhci_td *td = NULL; /* Since urb->number_of_packets > 0 */
Alan Stern0ed8fee2005-12-17 18:02:38 -05001235 int i, frame;
Alan Sterndccf4a42005-12-17 17:58:46 -05001236 unsigned long destination, status;
Alan Sternb81d3432005-10-13 17:00:24 -04001237 struct urb_priv *urbp = (struct urb_priv *) urb->hcpriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238
Alan Sterncaf38272006-05-19 16:44:55 -04001239 /* Values must not be too big (could overflow below) */
1240 if (urb->interval >= UHCI_NUMFRAMES ||
1241 urb->number_of_packets >= UHCI_NUMFRAMES)
1242 return -EFBIG;
1243
1244 /* Check the period and figure out the starting frame number */
Alan Stern3ca2a322007-01-16 11:56:32 -05001245 if (!qh->bandwidth_reserved) {
1246 qh->period = urb->interval;
Alan Sterncaf38272006-05-19 16:44:55 -04001247 if (urb->transfer_flags & URB_ISO_ASAP) {
Alan Stern3ca2a322007-01-16 11:56:32 -05001248 qh->phase = -1; /* Find the best phase */
1249 i = uhci_check_bandwidth(uhci, qh);
1250 if (i)
1251 return i;
1252
1253 /* Allow a little time to allocate the TDs */
Alan Sternc8155cc2006-05-19 16:52:35 -04001254 uhci_get_current_frame_number(uhci);
Alan Stern3ca2a322007-01-16 11:56:32 -05001255 frame = uhci->frame_number + 10;
1256
1257 /* Move forward to the first frame having the
1258 * correct phase */
1259 urb->start_frame = frame + ((qh->phase - frame) &
1260 (qh->period - 1));
Alan Sterncaf38272006-05-19 16:44:55 -04001261 } else {
Alan Sternc8155cc2006-05-19 16:52:35 -04001262 i = urb->start_frame - uhci->last_iso_frame;
Alan Sterncaf38272006-05-19 16:44:55 -04001263 if (i <= 0 || i >= UHCI_NUMFRAMES)
1264 return -EINVAL;
Alan Stern3ca2a322007-01-16 11:56:32 -05001265 qh->phase = urb->start_frame & (qh->period - 1);
1266 i = uhci_check_bandwidth(uhci, qh);
1267 if (i)
1268 return i;
Alan Sterncaf38272006-05-19 16:44:55 -04001269 }
Alan Stern3ca2a322007-01-16 11:56:32 -05001270
Alan Sterncaf38272006-05-19 16:44:55 -04001271 } else if (qh->period != urb->interval) {
1272 return -EINVAL; /* Can't change the period */
1273
1274 } else { /* Pick up where the last URB leaves off */
1275 if (list_empty(&qh->queue)) {
Alan Sternc8155cc2006-05-19 16:52:35 -04001276 frame = qh->iso_frame;
Alan Sterncaf38272006-05-19 16:44:55 -04001277 } else {
1278 struct urb *lurb;
1279
1280 lurb = list_entry(qh->queue.prev,
1281 struct urb_priv, node)->urb;
1282 frame = lurb->start_frame +
1283 lurb->number_of_packets *
1284 lurb->interval;
1285 }
1286 if (urb->transfer_flags & URB_ISO_ASAP)
1287 urb->start_frame = frame;
Alan Sternc8155cc2006-05-19 16:52:35 -04001288 else if (urb->start_frame != frame)
1289 return -EINVAL;
Alan Sterncaf38272006-05-19 16:44:55 -04001290 }
1291
1292 /* Make sure we won't have to go too far into the future */
Alan Sternc8155cc2006-05-19 16:52:35 -04001293 if (uhci_frame_before_eq(uhci->last_iso_frame + UHCI_NUMFRAMES,
Alan Sterncaf38272006-05-19 16:44:55 -04001294 urb->start_frame + urb->number_of_packets *
1295 urb->interval))
Alan Stern0ed8fee2005-12-17 18:02:38 -05001296 return -EFBIG;
1297
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 status = TD_CTRL_ACTIVE | TD_CTRL_IOS;
1299 destination = (urb->pipe & PIPE_DEVEP_MASK) | usb_packetid(urb->pipe);
1300
Alan Sternb81d3432005-10-13 17:00:24 -04001301 for (i = 0; i < urb->number_of_packets; i++) {
Alan Stern25321782005-04-25 11:14:31 -04001302 td = uhci_alloc_td(uhci);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 if (!td)
1304 return -ENOMEM;
1305
Alan Stern04538a22006-05-12 11:29:04 -04001306 uhci_add_td_to_urbp(td, urbp);
Alan Sterndccf4a42005-12-17 17:58:46 -05001307 uhci_fill_td(td, status, destination |
1308 uhci_explen(urb->iso_frame_desc[i].length),
1309 urb->transfer_dma +
1310 urb->iso_frame_desc[i].offset);
Alan Sternb81d3432005-10-13 17:00:24 -04001311 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312
Alan Sterndccf4a42005-12-17 17:58:46 -05001313 /* Set the interrupt-on-completion flag on the last packet. */
1314 td->status |= __constant_cpu_to_le32(TD_CTRL_IOC);
1315
Alan Sterndccf4a42005-12-17 17:58:46 -05001316 /* Add the TDs to the frame list */
Alan Sternb81d3432005-10-13 17:00:24 -04001317 frame = urb->start_frame;
1318 list_for_each_entry(td, &urbp->td_list, list) {
Alan Sterndccf4a42005-12-17 17:58:46 -05001319 uhci_insert_td_in_frame_list(uhci, td, frame);
Alan Sternc8155cc2006-05-19 16:52:35 -04001320 frame += qh->period;
1321 }
1322
1323 if (list_empty(&qh->queue)) {
1324 qh->iso_packet_desc = &urb->iso_frame_desc[0];
1325 qh->iso_frame = urb->start_frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 }
1327
Alan Stern17230ac2007-02-19 15:52:45 -05001328 qh->skel = SKEL_ISO;
Alan Stern3ca2a322007-01-16 11:56:32 -05001329 if (!qh->bandwidth_reserved)
1330 uhci_reserve_bandwidth(uhci, qh);
Alan Sterndccf4a42005-12-17 17:58:46 -05001331 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332}
1333
1334static int uhci_result_isochronous(struct uhci_hcd *uhci, struct urb *urb)
1335{
Alan Sternc8155cc2006-05-19 16:52:35 -04001336 struct uhci_td *td, *tmp;
1337 struct urb_priv *urbp = urb->hcpriv;
1338 struct uhci_qh *qh = urbp->qh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339
Alan Sternc8155cc2006-05-19 16:52:35 -04001340 list_for_each_entry_safe(td, tmp, &urbp->td_list, list) {
1341 unsigned int ctrlstat;
1342 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 int actlength;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344
Alan Sternc8155cc2006-05-19 16:52:35 -04001345 if (uhci_frame_before_eq(uhci->cur_iso_frame, qh->iso_frame))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 return -EINPROGRESS;
1347
Alan Sternc8155cc2006-05-19 16:52:35 -04001348 uhci_remove_tds_from_frame(uhci, qh->iso_frame);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349
Alan Sternc8155cc2006-05-19 16:52:35 -04001350 ctrlstat = td_status(td);
1351 if (ctrlstat & TD_CTRL_ACTIVE) {
1352 status = -EXDEV; /* TD was added too late? */
1353 } else {
1354 status = uhci_map_status(uhci_status_bits(ctrlstat),
1355 usb_pipeout(urb->pipe));
1356 actlength = uhci_actual_length(ctrlstat);
1357
1358 urb->actual_length += actlength;
1359 qh->iso_packet_desc->actual_length = actlength;
1360 qh->iso_packet_desc->status = status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 }
Alan Sternee7d1f32007-08-21 15:37:50 -04001362 if (status)
Alan Sternc8155cc2006-05-19 16:52:35 -04001363 urb->error_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364
Alan Sternc8155cc2006-05-19 16:52:35 -04001365 uhci_remove_td_from_urbp(td);
1366 uhci_free_td(uhci, td);
1367 qh->iso_frame += qh->period;
1368 ++qh->iso_packet_desc;
1369 }
Alan Sternee7d1f32007-08-21 15:37:50 -04001370 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371}
1372
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373static int uhci_urb_enqueue(struct usb_hcd *hcd,
Al Viro55016f12005-10-21 03:21:58 -04001374 struct urb *urb, gfp_t mem_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375{
1376 int ret;
1377 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
1378 unsigned long flags;
Alan Sterndccf4a42005-12-17 17:58:46 -05001379 struct urb_priv *urbp;
1380 struct uhci_qh *qh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381
1382 spin_lock_irqsave(&uhci->lock, flags);
1383
Alan Sterne9df41c2007-08-08 11:48:02 -04001384 ret = usb_hcd_link_urb_to_ep(hcd, urb);
1385 if (ret)
1386 goto done_not_linked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387
Alan Sterndccf4a42005-12-17 17:58:46 -05001388 ret = -ENOMEM;
1389 urbp = uhci_alloc_urb_priv(uhci, urb);
1390 if (!urbp)
1391 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392
Alan Sterne9df41c2007-08-08 11:48:02 -04001393 if (urb->ep->hcpriv)
1394 qh = urb->ep->hcpriv;
Alan Sterndccf4a42005-12-17 17:58:46 -05001395 else {
Alan Sterne9df41c2007-08-08 11:48:02 -04001396 qh = uhci_alloc_qh(uhci, urb->dev, urb->ep);
Alan Sterndccf4a42005-12-17 17:58:46 -05001397 if (!qh)
1398 goto err_no_qh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 }
Alan Sterndccf4a42005-12-17 17:58:46 -05001400 urbp->qh = qh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401
Alan Stern4de7d2c2006-05-05 16:26:58 -04001402 switch (qh->type) {
1403 case USB_ENDPOINT_XFER_CONTROL:
Alan Sterndccf4a42005-12-17 17:58:46 -05001404 ret = uhci_submit_control(uhci, urb, qh);
1405 break;
Alan Stern4de7d2c2006-05-05 16:26:58 -04001406 case USB_ENDPOINT_XFER_BULK:
Alan Sterndccf4a42005-12-17 17:58:46 -05001407 ret = uhci_submit_bulk(uhci, urb, qh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 break;
Alan Stern4de7d2c2006-05-05 16:26:58 -04001409 case USB_ENDPOINT_XFER_INT:
Alan Stern3ca2a322007-01-16 11:56:32 -05001410 ret = uhci_submit_interrupt(uhci, urb, qh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 break;
Alan Stern4de7d2c2006-05-05 16:26:58 -04001412 case USB_ENDPOINT_XFER_ISOC:
Alan Sternc8155cc2006-05-19 16:52:35 -04001413 urb->error_count = 0;
Alan Sterndccf4a42005-12-17 17:58:46 -05001414 ret = uhci_submit_isochronous(uhci, urb, qh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 break;
1416 }
Alan Sterndccf4a42005-12-17 17:58:46 -05001417 if (ret != 0)
1418 goto err_submit_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419
Alan Sterndccf4a42005-12-17 17:58:46 -05001420 /* Add this URB to the QH */
1421 urbp->qh = qh;
1422 list_add_tail(&urbp->node, &qh->queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423
Alan Sterndccf4a42005-12-17 17:58:46 -05001424 /* If the new URB is the first and only one on this QH then either
1425 * the QH is new and idle or else it's unlinked and waiting to
Alan Stern27755622006-05-05 16:32:02 -04001426 * become idle, so we can activate it right away. But only if the
1427 * queue isn't stopped. */
Alan Stern84afddd2006-05-12 11:35:45 -04001428 if (qh->queue.next == &urbp->node && !qh->is_stopped) {
Alan Sterndccf4a42005-12-17 17:58:46 -05001429 uhci_activate_qh(uhci, qh);
Alan Sternc5e3b742006-06-05 12:28:57 -04001430 uhci_urbp_wants_fsbr(uhci, urbp);
Alan Stern84afddd2006-05-12 11:35:45 -04001431 }
Alan Sterndccf4a42005-12-17 17:58:46 -05001432 goto done;
1433
1434err_submit_failed:
1435 if (qh->state == QH_STATE_IDLE)
1436 uhci_make_qh_idle(uhci, qh); /* Reclaim unused QH */
Alan Sterndccf4a42005-12-17 17:58:46 -05001437err_no_qh:
1438 uhci_free_urb_priv(uhci, urbp);
Alan Sterndccf4a42005-12-17 17:58:46 -05001439done:
Alan Sterne9df41c2007-08-08 11:48:02 -04001440 if (ret)
1441 usb_hcd_unlink_urb_from_ep(hcd, urb);
1442done_not_linked:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 spin_unlock_irqrestore(&uhci->lock, flags);
1444 return ret;
1445}
1446
Alan Sterne9df41c2007-08-08 11:48:02 -04001447static int uhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448{
1449 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
1450 unsigned long flags;
Alan Stern10b8e472006-05-19 16:39:52 -04001451 struct uhci_qh *qh;
Alan Sterne9df41c2007-08-08 11:48:02 -04001452 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453
1454 spin_lock_irqsave(&uhci->lock, flags);
Alan Sterne9df41c2007-08-08 11:48:02 -04001455 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
1456 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 goto done;
Alan Sterne9df41c2007-08-08 11:48:02 -04001458
1459 qh = ((struct urb_priv *) urb->hcpriv)->qh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460
Alan Sterndccf4a42005-12-17 17:58:46 -05001461 /* Remove Isochronous TDs from the frame list ASAP */
Alan Stern10b8e472006-05-19 16:39:52 -04001462 if (qh->type == USB_ENDPOINT_XFER_ISOC) {
Alan Sterndccf4a42005-12-17 17:58:46 -05001463 uhci_unlink_isochronous_tds(uhci, urb);
Alan Stern10b8e472006-05-19 16:39:52 -04001464 mb();
1465
1466 /* If the URB has already started, update the QH unlink time */
1467 uhci_get_current_frame_number(uhci);
1468 if (uhci_frame_before_eq(urb->start_frame, uhci->frame_number))
1469 qh->unlink_frame = uhci->frame_number;
1470 }
1471
1472 uhci_unlink_qh(uhci, qh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473
1474done:
1475 spin_unlock_irqrestore(&uhci->lock, flags);
Alan Sterne9df41c2007-08-08 11:48:02 -04001476 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477}
1478
Alan Stern0ed8fee2005-12-17 18:02:38 -05001479/*
1480 * Finish unlinking an URB and give it back
1481 */
1482static void uhci_giveback_urb(struct uhci_hcd *uhci, struct uhci_qh *qh,
David Howells7d12e782006-10-05 14:55:46 +01001483 struct urb *urb)
Alan Stern0ed8fee2005-12-17 18:02:38 -05001484__releases(uhci->lock)
1485__acquires(uhci->lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486{
Alan Stern0ed8fee2005-12-17 18:02:38 -05001487 struct urb_priv *urbp = (struct urb_priv *) urb->hcpriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488
Alan Sterne7e7c362007-07-13 15:46:29 -04001489 if (qh->type == USB_ENDPOINT_XFER_CONTROL) {
1490
1491 /* urb->actual_length < 0 means the setup transaction didn't
1492 * complete successfully. Either it failed or the URB was
1493 * unlinked first. Regardless, don't confuse people with a
1494 * negative length. */
1495 urb->actual_length = max(urb->actual_length, 0);
Alan Sterne7e7c362007-07-13 15:46:29 -04001496 }
1497
Alan Sternc8155cc2006-05-19 16:52:35 -04001498 /* When giving back the first URB in an Isochronous queue,
1499 * reinitialize the QH's iso-related members for the next URB. */
Alan Sterne7e7c362007-07-13 15:46:29 -04001500 else if (qh->type == USB_ENDPOINT_XFER_ISOC &&
Alan Sternc8155cc2006-05-19 16:52:35 -04001501 urbp->node.prev == &qh->queue &&
1502 urbp->node.next != &qh->queue) {
1503 struct urb *nurb = list_entry(urbp->node.next,
1504 struct urb_priv, node)->urb;
1505
1506 qh->iso_packet_desc = &nurb->iso_frame_desc[0];
1507 qh->iso_frame = nurb->start_frame;
Alan Sternc8155cc2006-05-19 16:52:35 -04001508 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509
Alan Stern0ed8fee2005-12-17 18:02:38 -05001510 /* Take the URB off the QH's queue. If the queue is now empty,
1511 * this is a perfect time for a toggle fixup. */
1512 list_del_init(&urbp->node);
1513 if (list_empty(&qh->queue) && qh->needs_fixup) {
1514 usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
1515 usb_pipeout(urb->pipe), qh->initial_toggle);
1516 qh->needs_fixup = 0;
1517 }
1518
Alan Stern0ed8fee2005-12-17 18:02:38 -05001519 uhci_free_urb_priv(uhci, urbp);
Alan Sterne9df41c2007-08-08 11:48:02 -04001520 usb_hcd_unlink_urb_from_ep(uhci_to_hcd(uhci), urb);
Alan Stern0ed8fee2005-12-17 18:02:38 -05001521
Alan Stern0ed8fee2005-12-17 18:02:38 -05001522 spin_unlock(&uhci->lock);
David Howells7d12e782006-10-05 14:55:46 +01001523 usb_hcd_giveback_urb(uhci_to_hcd(uhci), urb);
Alan Stern0ed8fee2005-12-17 18:02:38 -05001524 spin_lock(&uhci->lock);
1525
1526 /* If the queue is now empty, we can unlink the QH and give up its
1527 * reserved bandwidth. */
1528 if (list_empty(&qh->queue)) {
1529 uhci_unlink_qh(uhci, qh);
Alan Stern3ca2a322007-01-16 11:56:32 -05001530 if (qh->bandwidth_reserved)
1531 uhci_release_bandwidth(uhci, qh);
Alan Stern0ed8fee2005-12-17 18:02:38 -05001532 }
1533}
1534
1535/*
1536 * Scan the URBs in a QH's queue
1537 */
1538#define QH_FINISHED_UNLINKING(qh) \
1539 (qh->state == QH_STATE_UNLINKING && \
1540 uhci->frame_number + uhci->is_stopped != qh->unlink_frame)
1541
David Howells7d12e782006-10-05 14:55:46 +01001542static void uhci_scan_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
Alan Stern0ed8fee2005-12-17 18:02:38 -05001543{
1544 struct urb_priv *urbp;
1545 struct urb *urb;
1546 int status;
1547
1548 while (!list_empty(&qh->queue)) {
1549 urbp = list_entry(qh->queue.next, struct urb_priv, node);
1550 urb = urbp->urb;
1551
Alan Sternb1869002006-05-12 11:14:25 -04001552 if (qh->type == USB_ENDPOINT_XFER_ISOC)
Alan Stern0ed8fee2005-12-17 18:02:38 -05001553 status = uhci_result_isochronous(uhci, urb);
Alan Sternb1869002006-05-12 11:14:25 -04001554 else
Alan Stern0ed8fee2005-12-17 18:02:38 -05001555 status = uhci_result_common(uhci, urb);
Alan Stern0ed8fee2005-12-17 18:02:38 -05001556 if (status == -EINPROGRESS)
1557 break;
1558
1559 spin_lock(&urb->lock);
Alan Sterneb231052007-08-21 15:40:36 -04001560 urb->status = status;
Alan Stern0ed8fee2005-12-17 18:02:38 -05001561 spin_unlock(&urb->lock);
1562
1563 /* Dequeued but completed URBs can't be given back unless
1564 * the QH is stopped or has finished unlinking. */
Alan Sterneb231052007-08-21 15:40:36 -04001565 if (urb->unlinked) {
Alan Stern27755622006-05-05 16:32:02 -04001566 if (QH_FINISHED_UNLINKING(qh))
1567 qh->is_stopped = 1;
1568 else if (!qh->is_stopped)
1569 return;
1570 }
Alan Stern0ed8fee2005-12-17 18:02:38 -05001571
David Howells7d12e782006-10-05 14:55:46 +01001572 uhci_giveback_urb(uhci, qh, urb);
Alan Sternee7d1f32007-08-21 15:37:50 -04001573 if (status < 0)
Alan Stern0ed8fee2005-12-17 18:02:38 -05001574 break;
1575 }
1576
1577 /* If the QH is neither stopped nor finished unlinking (normal case),
1578 * our work here is done. */
Alan Stern27755622006-05-05 16:32:02 -04001579 if (QH_FINISHED_UNLINKING(qh))
1580 qh->is_stopped = 1;
1581 else if (!qh->is_stopped)
Alan Stern0ed8fee2005-12-17 18:02:38 -05001582 return;
1583
1584 /* Otherwise give back each of the dequeued URBs */
Alan Stern27755622006-05-05 16:32:02 -04001585restart:
Alan Stern0ed8fee2005-12-17 18:02:38 -05001586 list_for_each_entry(urbp, &qh->queue, node) {
1587 urb = urbp->urb;
Alan Sterneb231052007-08-21 15:40:36 -04001588 if (urb->unlinked) {
Alan Stern10b8e472006-05-19 16:39:52 -04001589
1590 /* Fix up the TD links and save the toggles for
1591 * non-Isochronous queues. For Isochronous queues,
1592 * test for too-recent dequeues. */
1593 if (!uhci_cleanup_queue(uhci, qh, urb)) {
1594 qh->is_stopped = 0;
1595 return;
1596 }
David Howells7d12e782006-10-05 14:55:46 +01001597 uhci_giveback_urb(uhci, qh, urb);
Alan Stern0ed8fee2005-12-17 18:02:38 -05001598 goto restart;
1599 }
1600 }
1601 qh->is_stopped = 0;
1602
1603 /* There are no more dequeued URBs. If there are still URBs on the
1604 * queue, the QH can now be re-activated. */
1605 if (!list_empty(&qh->queue)) {
1606 if (qh->needs_fixup)
1607 uhci_fixup_toggles(qh, 0);
Alan Stern84afddd2006-05-12 11:35:45 -04001608
1609 /* If the first URB on the queue wants FSBR but its time
1610 * limit has expired, set the next TD to interrupt on
1611 * completion before reactivating the QH. */
1612 urbp = list_entry(qh->queue.next, struct urb_priv, node);
1613 if (urbp->fsbr && qh->wait_expired) {
1614 struct uhci_td *td = list_entry(urbp->td_list.next,
1615 struct uhci_td, list);
1616
1617 td->status |= __cpu_to_le32(TD_CTRL_IOC);
1618 }
1619
Alan Stern0ed8fee2005-12-17 18:02:38 -05001620 uhci_activate_qh(uhci, qh);
1621 }
1622
1623 /* The queue is empty. The QH can become idle if it is fully
1624 * unlinked. */
1625 else if (QH_FINISHED_UNLINKING(qh))
1626 uhci_make_qh_idle(uhci, qh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627}
1628
Alan Stern0ed8fee2005-12-17 18:02:38 -05001629/*
Alan Stern84afddd2006-05-12 11:35:45 -04001630 * Check for queues that have made some forward progress.
1631 * Returns 0 if the queue is not Isochronous, is ACTIVE, and
1632 * has not advanced since last examined; 1 otherwise.
Alan Sternb761d9d2006-05-12 11:41:59 -04001633 *
1634 * Early Intel controllers have a bug which causes qh->element sometimes
1635 * not to advance when a TD completes successfully. The queue remains
1636 * stuck on the inactive completed TD. We detect such cases and advance
1637 * the element pointer by hand.
Alan Stern84afddd2006-05-12 11:35:45 -04001638 */
1639static int uhci_advance_check(struct uhci_hcd *uhci, struct uhci_qh *qh)
1640{
1641 struct urb_priv *urbp = NULL;
1642 struct uhci_td *td;
1643 int ret = 1;
1644 unsigned status;
1645
1646 if (qh->type == USB_ENDPOINT_XFER_ISOC)
Alan Sternc5e3b742006-06-05 12:28:57 -04001647 goto done;
Alan Stern84afddd2006-05-12 11:35:45 -04001648
1649 /* Treat an UNLINKING queue as though it hasn't advanced.
1650 * This is okay because reactivation will treat it as though
1651 * it has advanced, and if it is going to become IDLE then
1652 * this doesn't matter anyway. Furthermore it's possible
1653 * for an UNLINKING queue not to have any URBs at all, or
1654 * for its first URB not to have any TDs (if it was dequeued
1655 * just as it completed). So it's not easy in any case to
1656 * test whether such queues have advanced. */
1657 if (qh->state != QH_STATE_ACTIVE) {
1658 urbp = NULL;
1659 status = 0;
1660
1661 } else {
1662 urbp = list_entry(qh->queue.next, struct urb_priv, node);
1663 td = list_entry(urbp->td_list.next, struct uhci_td, list);
1664 status = td_status(td);
1665 if (!(status & TD_CTRL_ACTIVE)) {
1666
1667 /* We're okay, the queue has advanced */
1668 qh->wait_expired = 0;
1669 qh->advance_jiffies = jiffies;
Alan Sternc5e3b742006-06-05 12:28:57 -04001670 goto done;
Alan Stern84afddd2006-05-12 11:35:45 -04001671 }
1672 ret = 0;
1673 }
1674
1675 /* The queue hasn't advanced; check for timeout */
Alan Sternc5e3b742006-06-05 12:28:57 -04001676 if (qh->wait_expired)
1677 goto done;
1678
1679 if (time_after(jiffies, qh->advance_jiffies + QH_WAIT_TIMEOUT)) {
Alan Sternb761d9d2006-05-12 11:41:59 -04001680
1681 /* Detect the Intel bug and work around it */
Alan Stern28b93252007-02-19 15:51:51 -05001682 if (qh->post_td && qh_element(qh) == LINK_TO_TD(qh->post_td)) {
Alan Sternb761d9d2006-05-12 11:41:59 -04001683 qh->element = qh->post_td->link;
1684 qh->advance_jiffies = jiffies;
Alan Sternc5e3b742006-06-05 12:28:57 -04001685 ret = 1;
1686 goto done;
Alan Sternb761d9d2006-05-12 11:41:59 -04001687 }
1688
Alan Stern84afddd2006-05-12 11:35:45 -04001689 qh->wait_expired = 1;
1690
1691 /* If the current URB wants FSBR, unlink it temporarily
1692 * so that we can safely set the next TD to interrupt on
1693 * completion. That way we'll know as soon as the queue
1694 * starts moving again. */
1695 if (urbp && urbp->fsbr && !(status & TD_CTRL_IOC))
1696 uhci_unlink_qh(uhci, qh);
Alan Sternc5e3b742006-06-05 12:28:57 -04001697
1698 } else {
1699 /* Unmoving but not-yet-expired queues keep FSBR alive */
1700 if (urbp)
1701 uhci_urbp_wants_fsbr(uhci, urbp);
Alan Stern84afddd2006-05-12 11:35:45 -04001702 }
Alan Sternc5e3b742006-06-05 12:28:57 -04001703
1704done:
Alan Stern84afddd2006-05-12 11:35:45 -04001705 return ret;
1706}
1707
1708/*
Alan Stern0ed8fee2005-12-17 18:02:38 -05001709 * Process events in the schedule, but only in one thread at a time
1710 */
David Howells7d12e782006-10-05 14:55:46 +01001711static void uhci_scan_schedule(struct uhci_hcd *uhci)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712{
Alan Stern0ed8fee2005-12-17 18:02:38 -05001713 int i;
1714 struct uhci_qh *qh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715
1716 /* Don't allow re-entrant calls */
1717 if (uhci->scan_in_progress) {
1718 uhci->need_rescan = 1;
1719 return;
1720 }
1721 uhci->scan_in_progress = 1;
Alan Stern84afddd2006-05-12 11:35:45 -04001722rescan:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 uhci->need_rescan = 0;
Alan Sternc5e3b742006-06-05 12:28:57 -04001724 uhci->fsbr_is_wanted = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
Alan Stern6c1b4452005-04-21 16:04:58 -04001726 uhci_clear_next_interrupt(uhci);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 uhci_get_current_frame_number(uhci);
Alan Sternc8155cc2006-05-19 16:52:35 -04001728 uhci->cur_iso_frame = uhci->frame_number;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729
Alan Stern0ed8fee2005-12-17 18:02:38 -05001730 /* Go through all the QH queues and process the URBs in each one */
1731 for (i = 0; i < UHCI_NUM_SKELQH - 1; ++i) {
1732 uhci->next_qh = list_entry(uhci->skelqh[i]->node.next,
1733 struct uhci_qh, node);
1734 while ((qh = uhci->next_qh) != uhci->skelqh[i]) {
1735 uhci->next_qh = list_entry(qh->node.next,
1736 struct uhci_qh, node);
Alan Stern84afddd2006-05-12 11:35:45 -04001737
1738 if (uhci_advance_check(uhci, qh)) {
David Howells7d12e782006-10-05 14:55:46 +01001739 uhci_scan_qh(uhci, qh);
Alan Sternc5e3b742006-06-05 12:28:57 -04001740 if (qh->state == QH_STATE_ACTIVE) {
1741 uhci_urbp_wants_fsbr(uhci,
1742 list_entry(qh->queue.next, struct urb_priv, node));
1743 }
Alan Stern84afddd2006-05-12 11:35:45 -04001744 }
Alan Stern0ed8fee2005-12-17 18:02:38 -05001745 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747
Alan Sternc8155cc2006-05-19 16:52:35 -04001748 uhci->last_iso_frame = uhci->cur_iso_frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 if (uhci->need_rescan)
1750 goto rescan;
1751 uhci->scan_in_progress = 0;
1752
Alan Sternc5e3b742006-06-05 12:28:57 -04001753 if (uhci->fsbr_is_on && !uhci->fsbr_is_wanted &&
1754 !uhci->fsbr_expiring) {
1755 uhci->fsbr_expiring = 1;
1756 mod_timer(&uhci->fsbr_timer, jiffies + FSBR_OFF_DELAY);
1757 }
Alan Stern84afddd2006-05-12 11:35:45 -04001758
Alan Stern04538a22006-05-12 11:29:04 -04001759 if (list_empty(&uhci->skel_unlink_qh->node))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 uhci_clear_next_interrupt(uhci);
1761 else
1762 uhci_set_next_interrupt(uhci);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763}