11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Universal Host Controller Interface driver for USB. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Maintainer: Alan Stern <stern@rowland.harvard.edu> 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * (C) Copyright 1999 Linus Torvalds 71da177e4SLinus Torvalds * (C) Copyright 1999-2002 Johannes Erdfelt, johannes@erdfelt.com 81da177e4SLinus Torvalds * (C) Copyright 1999 Randy Dunlap 91da177e4SLinus Torvalds * (C) Copyright 1999 Georg Acher, acher@in.tum.de 101da177e4SLinus Torvalds * (C) Copyright 1999 Deti Fliegl, deti@fliegl.de 111da177e4SLinus Torvalds * (C) Copyright 1999 Thomas Sailer, sailer@ife.ee.ethz.ch 121da177e4SLinus Torvalds * (C) Copyright 1999 Roman Weissgaerber, weissg@vienna.at 131da177e4SLinus Torvalds * (C) Copyright 2000 Yggdrasil Computing, Inc. (port of new PCI interface 141da177e4SLinus Torvalds * support from usb-ohci.c by Adam Richter, adam@yggdrasil.com). 151da177e4SLinus Torvalds * (C) Copyright 1999 Gregory P. Smith (from usb-ohci.c) 1617230acdSAlan Stern * (C) Copyright 2004-2007 Alan Stern, stern@rowland.harvard.edu 171da177e4SLinus Torvalds */ 181da177e4SLinus Torvalds 191da177e4SLinus Torvalds 201da177e4SLinus Torvalds /* 211da177e4SLinus Torvalds * Technically, updating td->status here is a race, but it's not really a 221da177e4SLinus Torvalds * problem. The worst that can happen is that we set the IOC bit again 231da177e4SLinus Torvalds * generating a spurious interrupt. We could fix this by creating another 241da177e4SLinus Torvalds * QH and leaving the IOC bit always set, but then we would have to play 251da177e4SLinus Torvalds * games with the FSBR code to make sure we get the correct order in all 261da177e4SLinus Torvalds * the cases. I don't think it's worth the effort 271da177e4SLinus Torvalds */ 28dccf4a48SAlan Stern static void uhci_set_next_interrupt(struct uhci_hcd *uhci) 291da177e4SLinus Torvalds { 306c1b445cSAlan Stern if (uhci->is_stopped) 311f09df8bSAlan Stern mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies); 321da177e4SLinus Torvalds uhci->term_td->status |= cpu_to_le32(TD_CTRL_IOC); 331da177e4SLinus Torvalds } 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds static inline void uhci_clear_next_interrupt(struct uhci_hcd *uhci) 361da177e4SLinus Torvalds { 371da177e4SLinus Torvalds uhci->term_td->status &= ~cpu_to_le32(TD_CTRL_IOC); 381da177e4SLinus Torvalds } 391da177e4SLinus Torvalds 4084afddd7SAlan Stern 4184afddd7SAlan Stern /* 4284afddd7SAlan Stern * Full-Speed Bandwidth Reclamation (FSBR). 4384afddd7SAlan Stern * We turn on FSBR whenever a queue that wants it is advancing, 4484afddd7SAlan Stern * and leave it on for a short time thereafter. 4584afddd7SAlan Stern */ 4684afddd7SAlan Stern static void uhci_fsbr_on(struct uhci_hcd *uhci) 4784afddd7SAlan Stern { 48e009f1b2SAlan Stern struct uhci_qh *lqh; 4917230acdSAlan Stern 50e009f1b2SAlan Stern /* The terminating skeleton QH always points back to the first 51e009f1b2SAlan Stern * FSBR QH. Make the last async QH point to the terminating 52e009f1b2SAlan Stern * skeleton QH. */ 5384afddd7SAlan Stern uhci->fsbr_is_on = 1; 5417230acdSAlan Stern lqh = list_entry(uhci->skel_async_qh->node.prev, 5517230acdSAlan Stern struct uhci_qh, node); 56e009f1b2SAlan Stern lqh->link = LINK_TO_QH(uhci->skel_term_qh); 5784afddd7SAlan Stern } 5884afddd7SAlan Stern 5984afddd7SAlan Stern static void uhci_fsbr_off(struct uhci_hcd *uhci) 6084afddd7SAlan Stern { 6117230acdSAlan Stern struct uhci_qh *lqh; 6217230acdSAlan Stern 63e009f1b2SAlan Stern /* Remove the link from the last async QH to the terminating 64e009f1b2SAlan Stern * skeleton QH. */ 6584afddd7SAlan Stern uhci->fsbr_is_on = 0; 6617230acdSAlan Stern lqh = list_entry(uhci->skel_async_qh->node.prev, 6717230acdSAlan Stern struct uhci_qh, node); 68e009f1b2SAlan Stern lqh->link = UHCI_PTR_TERM; 6984afddd7SAlan Stern } 7084afddd7SAlan Stern 7184afddd7SAlan Stern static void uhci_add_fsbr(struct uhci_hcd *uhci, struct urb *urb) 7284afddd7SAlan Stern { 7384afddd7SAlan Stern struct urb_priv *urbp = urb->hcpriv; 7484afddd7SAlan Stern 7584afddd7SAlan Stern if (!(urb->transfer_flags & URB_NO_FSBR)) 7684afddd7SAlan Stern urbp->fsbr = 1; 7784afddd7SAlan Stern } 7884afddd7SAlan Stern 79c5e3b741SAlan Stern static void uhci_urbp_wants_fsbr(struct uhci_hcd *uhci, struct urb_priv *urbp) 8084afddd7SAlan Stern { 8184afddd7SAlan Stern if (urbp->fsbr) { 82c5e3b741SAlan Stern uhci->fsbr_is_wanted = 1; 8384afddd7SAlan Stern if (!uhci->fsbr_is_on) 8484afddd7SAlan Stern uhci_fsbr_on(uhci); 85c5e3b741SAlan Stern else if (uhci->fsbr_expiring) { 86c5e3b741SAlan Stern uhci->fsbr_expiring = 0; 87c5e3b741SAlan Stern del_timer(&uhci->fsbr_timer); 8884afddd7SAlan Stern } 8984afddd7SAlan Stern } 90c5e3b741SAlan Stern } 91c5e3b741SAlan Stern 92c5e3b741SAlan Stern static void uhci_fsbr_timeout(unsigned long _uhci) 93c5e3b741SAlan Stern { 94c5e3b741SAlan Stern struct uhci_hcd *uhci = (struct uhci_hcd *) _uhci; 95c5e3b741SAlan Stern unsigned long flags; 96c5e3b741SAlan Stern 97c5e3b741SAlan Stern spin_lock_irqsave(&uhci->lock, flags); 98c5e3b741SAlan Stern if (uhci->fsbr_expiring) { 99c5e3b741SAlan Stern uhci->fsbr_expiring = 0; 100c5e3b741SAlan Stern uhci_fsbr_off(uhci); 101c5e3b741SAlan Stern } 102c5e3b741SAlan Stern spin_unlock_irqrestore(&uhci->lock, flags); 103c5e3b741SAlan Stern } 10484afddd7SAlan Stern 10584afddd7SAlan Stern 1062532178aSAlan Stern static struct uhci_td *uhci_alloc_td(struct uhci_hcd *uhci) 1071da177e4SLinus Torvalds { 1081da177e4SLinus Torvalds dma_addr_t dma_handle; 1091da177e4SLinus Torvalds struct uhci_td *td; 1101da177e4SLinus Torvalds 1111da177e4SLinus Torvalds td = dma_pool_alloc(uhci->td_pool, GFP_ATOMIC, &dma_handle); 1121da177e4SLinus Torvalds if (!td) 1131da177e4SLinus Torvalds return NULL; 1141da177e4SLinus Torvalds 1151da177e4SLinus Torvalds td->dma_handle = dma_handle; 1161da177e4SLinus Torvalds td->frame = -1; 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds INIT_LIST_HEAD(&td->list); 1191da177e4SLinus Torvalds INIT_LIST_HEAD(&td->fl_list); 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds return td; 1221da177e4SLinus Torvalds } 1231da177e4SLinus Torvalds 124dccf4a48SAlan Stern static void uhci_free_td(struct uhci_hcd *uhci, struct uhci_td *td) 125dccf4a48SAlan Stern { 126*5172046dSArjan van de Ven if (!list_empty(&td->list)) 127*5172046dSArjan van de Ven dev_WARN(uhci_dev(uhci), "td %p still in list!\n", td); 128*5172046dSArjan van de Ven if (!list_empty(&td->fl_list)) 129*5172046dSArjan van de Ven dev_WARN(uhci_dev(uhci), "td %p still in fl_list!\n", td); 130dccf4a48SAlan Stern 131dccf4a48SAlan Stern dma_pool_free(uhci->td_pool, td, td->dma_handle); 132dccf4a48SAlan Stern } 133dccf4a48SAlan Stern 1341da177e4SLinus Torvalds static inline void uhci_fill_td(struct uhci_td *td, u32 status, 1351da177e4SLinus Torvalds u32 token, u32 buffer) 1361da177e4SLinus Torvalds { 1371da177e4SLinus Torvalds td->status = cpu_to_le32(status); 1381da177e4SLinus Torvalds td->token = cpu_to_le32(token); 1391da177e4SLinus Torvalds td->buffer = cpu_to_le32(buffer); 1401da177e4SLinus Torvalds } 1411da177e4SLinus Torvalds 14204538a25SAlan Stern static void uhci_add_td_to_urbp(struct uhci_td *td, struct urb_priv *urbp) 14304538a25SAlan Stern { 14404538a25SAlan Stern list_add_tail(&td->list, &urbp->td_list); 14504538a25SAlan Stern } 14604538a25SAlan Stern 14704538a25SAlan Stern static void uhci_remove_td_from_urbp(struct uhci_td *td) 14804538a25SAlan Stern { 14904538a25SAlan Stern list_del_init(&td->list); 15004538a25SAlan Stern } 15104538a25SAlan Stern 1521da177e4SLinus Torvalds /* 153687f5f34SAlan Stern * We insert Isochronous URBs directly into the frame list at the beginning 1541da177e4SLinus Torvalds */ 155dccf4a48SAlan Stern static inline void uhci_insert_td_in_frame_list(struct uhci_hcd *uhci, 156dccf4a48SAlan Stern struct uhci_td *td, unsigned framenum) 1571da177e4SLinus Torvalds { 1581da177e4SLinus Torvalds framenum &= (UHCI_NUMFRAMES - 1); 1591da177e4SLinus Torvalds 1601da177e4SLinus Torvalds td->frame = framenum; 1611da177e4SLinus Torvalds 1621da177e4SLinus Torvalds /* Is there a TD already mapped there? */ 163a1d59ce8SAlan Stern if (uhci->frame_cpu[framenum]) { 1641da177e4SLinus Torvalds struct uhci_td *ftd, *ltd; 1651da177e4SLinus Torvalds 166a1d59ce8SAlan Stern ftd = uhci->frame_cpu[framenum]; 1671da177e4SLinus Torvalds ltd = list_entry(ftd->fl_list.prev, struct uhci_td, fl_list); 1681da177e4SLinus Torvalds 1691da177e4SLinus Torvalds list_add_tail(&td->fl_list, &ftd->fl_list); 1701da177e4SLinus Torvalds 1711da177e4SLinus Torvalds td->link = ltd->link; 1721da177e4SLinus Torvalds wmb(); 17328b9325eSAlan Stern ltd->link = LINK_TO_TD(td); 1741da177e4SLinus Torvalds } else { 175a1d59ce8SAlan Stern td->link = uhci->frame[framenum]; 1761da177e4SLinus Torvalds wmb(); 17728b9325eSAlan Stern uhci->frame[framenum] = LINK_TO_TD(td); 178a1d59ce8SAlan Stern uhci->frame_cpu[framenum] = td; 1791da177e4SLinus Torvalds } 1801da177e4SLinus Torvalds } 1811da177e4SLinus Torvalds 182dccf4a48SAlan Stern static inline void uhci_remove_td_from_frame_list(struct uhci_hcd *uhci, 183b81d3436SAlan Stern struct uhci_td *td) 1841da177e4SLinus Torvalds { 1851da177e4SLinus Torvalds /* If it's not inserted, don't remove it */ 186b81d3436SAlan Stern if (td->frame == -1) { 187b81d3436SAlan Stern WARN_ON(!list_empty(&td->fl_list)); 1881da177e4SLinus Torvalds return; 189b81d3436SAlan Stern } 1901da177e4SLinus Torvalds 191b81d3436SAlan Stern if (uhci->frame_cpu[td->frame] == td) { 1921da177e4SLinus Torvalds if (list_empty(&td->fl_list)) { 193a1d59ce8SAlan Stern uhci->frame[td->frame] = td->link; 194a1d59ce8SAlan Stern uhci->frame_cpu[td->frame] = NULL; 1951da177e4SLinus Torvalds } else { 1961da177e4SLinus Torvalds struct uhci_td *ntd; 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds ntd = list_entry(td->fl_list.next, struct uhci_td, fl_list); 19928b9325eSAlan Stern uhci->frame[td->frame] = LINK_TO_TD(ntd); 200a1d59ce8SAlan Stern uhci->frame_cpu[td->frame] = ntd; 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds } else { 2031da177e4SLinus Torvalds struct uhci_td *ptd; 2041da177e4SLinus Torvalds 2051da177e4SLinus Torvalds ptd = list_entry(td->fl_list.prev, struct uhci_td, fl_list); 2061da177e4SLinus Torvalds ptd->link = td->link; 2071da177e4SLinus Torvalds } 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds list_del_init(&td->fl_list); 2101da177e4SLinus Torvalds td->frame = -1; 2111da177e4SLinus Torvalds } 2121da177e4SLinus Torvalds 213c8155cc5SAlan Stern static inline void uhci_remove_tds_from_frame(struct uhci_hcd *uhci, 214c8155cc5SAlan Stern unsigned int framenum) 215c8155cc5SAlan Stern { 216c8155cc5SAlan Stern struct uhci_td *ftd, *ltd; 217c8155cc5SAlan Stern 218c8155cc5SAlan Stern framenum &= (UHCI_NUMFRAMES - 1); 219c8155cc5SAlan Stern 220c8155cc5SAlan Stern ftd = uhci->frame_cpu[framenum]; 221c8155cc5SAlan Stern if (ftd) { 222c8155cc5SAlan Stern ltd = list_entry(ftd->fl_list.prev, struct uhci_td, fl_list); 223c8155cc5SAlan Stern uhci->frame[framenum] = ltd->link; 224c8155cc5SAlan Stern uhci->frame_cpu[framenum] = NULL; 225c8155cc5SAlan Stern 226c8155cc5SAlan Stern while (!list_empty(&ftd->fl_list)) 227c8155cc5SAlan Stern list_del_init(ftd->fl_list.prev); 228c8155cc5SAlan Stern } 229c8155cc5SAlan Stern } 230c8155cc5SAlan Stern 231dccf4a48SAlan Stern /* 232dccf4a48SAlan Stern * Remove all the TDs for an Isochronous URB from the frame list 233dccf4a48SAlan Stern */ 234dccf4a48SAlan Stern static void uhci_unlink_isochronous_tds(struct uhci_hcd *uhci, struct urb *urb) 235b81d3436SAlan Stern { 236b81d3436SAlan Stern struct urb_priv *urbp = (struct urb_priv *) urb->hcpriv; 237b81d3436SAlan Stern struct uhci_td *td; 238b81d3436SAlan Stern 239b81d3436SAlan Stern list_for_each_entry(td, &urbp->td_list, list) 240dccf4a48SAlan Stern uhci_remove_td_from_frame_list(uhci, td); 241b81d3436SAlan Stern } 242b81d3436SAlan Stern 243dccf4a48SAlan Stern static struct uhci_qh *uhci_alloc_qh(struct uhci_hcd *uhci, 244dccf4a48SAlan Stern struct usb_device *udev, struct usb_host_endpoint *hep) 2451da177e4SLinus Torvalds { 2461da177e4SLinus Torvalds dma_addr_t dma_handle; 2471da177e4SLinus Torvalds struct uhci_qh *qh; 2481da177e4SLinus Torvalds 2491da177e4SLinus Torvalds qh = dma_pool_alloc(uhci->qh_pool, GFP_ATOMIC, &dma_handle); 2501da177e4SLinus Torvalds if (!qh) 2511da177e4SLinus Torvalds return NULL; 2521da177e4SLinus Torvalds 25359e29ed9SAlan Stern memset(qh, 0, sizeof(*qh)); 2541da177e4SLinus Torvalds qh->dma_handle = dma_handle; 2551da177e4SLinus Torvalds 2561da177e4SLinus Torvalds qh->element = UHCI_PTR_TERM; 2571da177e4SLinus Torvalds qh->link = UHCI_PTR_TERM; 2581da177e4SLinus Torvalds 259dccf4a48SAlan Stern INIT_LIST_HEAD(&qh->queue); 260dccf4a48SAlan Stern INIT_LIST_HEAD(&qh->node); 2611da177e4SLinus Torvalds 262dccf4a48SAlan Stern if (udev) { /* Normal QH */ 26385a975d0SAlan Stern qh->type = hep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; 26485a975d0SAlan Stern if (qh->type != USB_ENDPOINT_XFER_ISOC) { 265af0bb599SAlan Stern qh->dummy_td = uhci_alloc_td(uhci); 266af0bb599SAlan Stern if (!qh->dummy_td) { 267af0bb599SAlan Stern dma_pool_free(uhci->qh_pool, qh, dma_handle); 268af0bb599SAlan Stern return NULL; 269af0bb599SAlan Stern } 27085a975d0SAlan Stern } 271dccf4a48SAlan Stern qh->state = QH_STATE_IDLE; 272dccf4a48SAlan Stern qh->hep = hep; 273dccf4a48SAlan Stern qh->udev = udev; 274dccf4a48SAlan Stern hep->hcpriv = qh; 2751da177e4SLinus Torvalds 2763ca2a321SAlan Stern if (qh->type == USB_ENDPOINT_XFER_INT || 2773ca2a321SAlan Stern qh->type == USB_ENDPOINT_XFER_ISOC) 2783ca2a321SAlan Stern qh->load = usb_calc_bus_time(udev->speed, 2793ca2a321SAlan Stern usb_endpoint_dir_in(&hep->desc), 2803ca2a321SAlan Stern qh->type == USB_ENDPOINT_XFER_ISOC, 2813ca2a321SAlan Stern le16_to_cpu(hep->desc.wMaxPacketSize)) 2823ca2a321SAlan Stern / 1000 + 1; 2833ca2a321SAlan Stern 284dccf4a48SAlan Stern } else { /* Skeleton QH */ 285dccf4a48SAlan Stern qh->state = QH_STATE_ACTIVE; 2864de7d2c2SAlan Stern qh->type = -1; 287dccf4a48SAlan Stern } 2881da177e4SLinus Torvalds return qh; 2891da177e4SLinus Torvalds } 2901da177e4SLinus Torvalds 2911da177e4SLinus Torvalds static void uhci_free_qh(struct uhci_hcd *uhci, struct uhci_qh *qh) 2921da177e4SLinus Torvalds { 293dccf4a48SAlan Stern WARN_ON(qh->state != QH_STATE_IDLE && qh->udev); 294*5172046dSArjan van de Ven if (!list_empty(&qh->queue)) 295*5172046dSArjan van de Ven dev_WARN(uhci_dev(uhci), "qh %p list not empty!\n", qh); 2961da177e4SLinus Torvalds 297dccf4a48SAlan Stern list_del(&qh->node); 298dccf4a48SAlan Stern if (qh->udev) { 299dccf4a48SAlan Stern qh->hep->hcpriv = NULL; 30085a975d0SAlan Stern if (qh->dummy_td) 301af0bb599SAlan Stern uhci_free_td(uhci, qh->dummy_td); 302dccf4a48SAlan Stern } 3031da177e4SLinus Torvalds dma_pool_free(uhci->qh_pool, qh, qh->dma_handle); 3041da177e4SLinus Torvalds } 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds /* 307a0b458b6SAlan Stern * When a queue is stopped and a dequeued URB is given back, adjust 308a0b458b6SAlan Stern * the previous TD link (if the URB isn't first on the queue) or 309a0b458b6SAlan Stern * save its toggle value (if it is first and is currently executing). 31010b8e47dSAlan Stern * 31110b8e47dSAlan Stern * Returns 0 if the URB should not yet be given back, 1 otherwise. 3120ed8fee1SAlan Stern */ 31310b8e47dSAlan Stern static int uhci_cleanup_queue(struct uhci_hcd *uhci, struct uhci_qh *qh, 314a0b458b6SAlan Stern struct urb *urb) 3150ed8fee1SAlan Stern { 316a0b458b6SAlan Stern struct urb_priv *urbp = urb->hcpriv; 3170ed8fee1SAlan Stern struct uhci_td *td; 31810b8e47dSAlan Stern int ret = 1; 3190ed8fee1SAlan Stern 320a0b458b6SAlan Stern /* Isochronous pipes don't use toggles and their TD link pointers 32110b8e47dSAlan Stern * get adjusted during uhci_urb_dequeue(). But since their queues 32210b8e47dSAlan Stern * cannot truly be stopped, we have to watch out for dequeues 32310b8e47dSAlan Stern * occurring after the nominal unlink frame. */ 32410b8e47dSAlan Stern if (qh->type == USB_ENDPOINT_XFER_ISOC) { 32510b8e47dSAlan Stern ret = (uhci->frame_number + uhci->is_stopped != 32610b8e47dSAlan Stern qh->unlink_frame); 327c5e3b741SAlan Stern goto done; 32810b8e47dSAlan Stern } 329a0b458b6SAlan Stern 330a0b458b6SAlan Stern /* If the URB isn't first on its queue, adjust the link pointer 331a0b458b6SAlan Stern * of the last TD in the previous URB. The toggle doesn't need 332a0b458b6SAlan Stern * to be saved since this URB can't be executing yet. */ 333a0b458b6SAlan Stern if (qh->queue.next != &urbp->node) { 334a0b458b6SAlan Stern struct urb_priv *purbp; 335a0b458b6SAlan Stern struct uhci_td *ptd; 336a0b458b6SAlan Stern 337a0b458b6SAlan Stern purbp = list_entry(urbp->node.prev, struct urb_priv, node); 338a0b458b6SAlan Stern WARN_ON(list_empty(&purbp->td_list)); 339a0b458b6SAlan Stern ptd = list_entry(purbp->td_list.prev, struct uhci_td, 340a0b458b6SAlan Stern list); 341a0b458b6SAlan Stern td = list_entry(urbp->td_list.prev, struct uhci_td, 342a0b458b6SAlan Stern list); 343a0b458b6SAlan Stern ptd->link = td->link; 344c5e3b741SAlan Stern goto done; 345a0b458b6SAlan Stern } 346a0b458b6SAlan Stern 3470ed8fee1SAlan Stern /* If the QH element pointer is UHCI_PTR_TERM then then currently 3480ed8fee1SAlan Stern * executing URB has already been unlinked, so this one isn't it. */ 349a0b458b6SAlan Stern if (qh_element(qh) == UHCI_PTR_TERM) 350c5e3b741SAlan Stern goto done; 3510ed8fee1SAlan Stern qh->element = UHCI_PTR_TERM; 3520ed8fee1SAlan Stern 35385a975d0SAlan Stern /* Control pipes don't have to worry about toggles */ 354a0b458b6SAlan Stern if (qh->type == USB_ENDPOINT_XFER_CONTROL) 355c5e3b741SAlan Stern goto done; 3560ed8fee1SAlan Stern 357a0b458b6SAlan Stern /* Save the next toggle value */ 35859e29ed9SAlan Stern WARN_ON(list_empty(&urbp->td_list)); 35959e29ed9SAlan Stern td = list_entry(urbp->td_list.next, struct uhci_td, list); 3600ed8fee1SAlan Stern qh->needs_fixup = 1; 3610ed8fee1SAlan Stern qh->initial_toggle = uhci_toggle(td_token(td)); 362c5e3b741SAlan Stern 363c5e3b741SAlan Stern done: 36410b8e47dSAlan Stern return ret; 3650ed8fee1SAlan Stern } 3660ed8fee1SAlan Stern 3670ed8fee1SAlan Stern /* 3680ed8fee1SAlan Stern * Fix up the data toggles for URBs in a queue, when one of them 3690ed8fee1SAlan Stern * terminates early (short transfer, error, or dequeued). 3700ed8fee1SAlan Stern */ 3710ed8fee1SAlan Stern static void uhci_fixup_toggles(struct uhci_qh *qh, int skip_first) 3720ed8fee1SAlan Stern { 3730ed8fee1SAlan Stern struct urb_priv *urbp = NULL; 3740ed8fee1SAlan Stern struct uhci_td *td; 3750ed8fee1SAlan Stern unsigned int toggle = qh->initial_toggle; 3760ed8fee1SAlan Stern unsigned int pipe; 3770ed8fee1SAlan Stern 3780ed8fee1SAlan Stern /* Fixups for a short transfer start with the second URB in the 3790ed8fee1SAlan Stern * queue (the short URB is the first). */ 3800ed8fee1SAlan Stern if (skip_first) 3810ed8fee1SAlan Stern urbp = list_entry(qh->queue.next, struct urb_priv, node); 3820ed8fee1SAlan Stern 3830ed8fee1SAlan Stern /* When starting with the first URB, if the QH element pointer is 3840ed8fee1SAlan Stern * still valid then we know the URB's toggles are okay. */ 3850ed8fee1SAlan Stern else if (qh_element(qh) != UHCI_PTR_TERM) 3860ed8fee1SAlan Stern toggle = 2; 3870ed8fee1SAlan Stern 3880ed8fee1SAlan Stern /* Fix up the toggle for the URBs in the queue. Normally this 3890ed8fee1SAlan Stern * loop won't run more than once: When an error or short transfer 3900ed8fee1SAlan Stern * occurs, the queue usually gets emptied. */ 3911393adb2SAlan Stern urbp = list_prepare_entry(urbp, &qh->queue, node); 3920ed8fee1SAlan Stern list_for_each_entry_continue(urbp, &qh->queue, node) { 3930ed8fee1SAlan Stern 3940ed8fee1SAlan Stern /* If the first TD has the right toggle value, we don't 3950ed8fee1SAlan Stern * need to change any toggles in this URB */ 3960ed8fee1SAlan Stern td = list_entry(urbp->td_list.next, struct uhci_td, list); 3970ed8fee1SAlan Stern if (toggle > 1 || uhci_toggle(td_token(td)) == toggle) { 398db59b464SAlan Stern td = list_entry(urbp->td_list.prev, struct uhci_td, 3990ed8fee1SAlan Stern list); 4000ed8fee1SAlan Stern toggle = uhci_toggle(td_token(td)) ^ 1; 4010ed8fee1SAlan Stern 4020ed8fee1SAlan Stern /* Otherwise all the toggles in the URB have to be switched */ 4030ed8fee1SAlan Stern } else { 4040ed8fee1SAlan Stern list_for_each_entry(td, &urbp->td_list, list) { 4050ed8fee1SAlan Stern td->token ^= __constant_cpu_to_le32( 4060ed8fee1SAlan Stern TD_TOKEN_TOGGLE); 4070ed8fee1SAlan Stern toggle ^= 1; 4080ed8fee1SAlan Stern } 4090ed8fee1SAlan Stern } 4100ed8fee1SAlan Stern } 4110ed8fee1SAlan Stern 4120ed8fee1SAlan Stern wmb(); 4130ed8fee1SAlan Stern pipe = list_entry(qh->queue.next, struct urb_priv, node)->urb->pipe; 4140ed8fee1SAlan Stern usb_settoggle(qh->udev, usb_pipeendpoint(pipe), 4150ed8fee1SAlan Stern usb_pipeout(pipe), toggle); 4160ed8fee1SAlan Stern qh->needs_fixup = 0; 4170ed8fee1SAlan Stern } 4180ed8fee1SAlan Stern 4190ed8fee1SAlan Stern /* 42017230acdSAlan Stern * Link an Isochronous QH into its skeleton's list 42117230acdSAlan Stern */ 42217230acdSAlan Stern static inline void link_iso(struct uhci_hcd *uhci, struct uhci_qh *qh) 42317230acdSAlan Stern { 42417230acdSAlan Stern list_add_tail(&qh->node, &uhci->skel_iso_qh->node); 42517230acdSAlan Stern 42617230acdSAlan Stern /* Isochronous QHs aren't linked by the hardware */ 42717230acdSAlan Stern } 42817230acdSAlan Stern 42917230acdSAlan Stern /* 43017230acdSAlan Stern * Link a high-period interrupt QH into the schedule at the end of its 43117230acdSAlan Stern * skeleton's list 43217230acdSAlan Stern */ 43317230acdSAlan Stern static void link_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh) 43417230acdSAlan Stern { 43517230acdSAlan Stern struct uhci_qh *pqh; 43617230acdSAlan Stern 43717230acdSAlan Stern list_add_tail(&qh->node, &uhci->skelqh[qh->skel]->node); 43817230acdSAlan Stern 43917230acdSAlan Stern pqh = list_entry(qh->node.prev, struct uhci_qh, node); 44017230acdSAlan Stern qh->link = pqh->link; 44117230acdSAlan Stern wmb(); 44217230acdSAlan Stern pqh->link = LINK_TO_QH(qh); 44317230acdSAlan Stern } 44417230acdSAlan Stern 44517230acdSAlan Stern /* 44617230acdSAlan Stern * Link a period-1 interrupt or async QH into the schedule at the 44717230acdSAlan Stern * correct spot in the async skeleton's list, and update the FSBR link 44817230acdSAlan Stern */ 44917230acdSAlan Stern static void link_async(struct uhci_hcd *uhci, struct uhci_qh *qh) 45017230acdSAlan Stern { 451e009f1b2SAlan Stern struct uhci_qh *pqh; 45217230acdSAlan Stern __le32 link_to_new_qh; 45317230acdSAlan Stern 45417230acdSAlan Stern /* Find the predecessor QH for our new one and insert it in the list. 45517230acdSAlan Stern * The list of QHs is expected to be short, so linear search won't 45617230acdSAlan Stern * take too long. */ 45717230acdSAlan Stern list_for_each_entry_reverse(pqh, &uhci->skel_async_qh->node, node) { 45817230acdSAlan Stern if (pqh->skel <= qh->skel) 45917230acdSAlan Stern break; 46017230acdSAlan Stern } 46117230acdSAlan Stern list_add(&qh->node, &pqh->node); 46217230acdSAlan Stern 46317230acdSAlan Stern /* Link it into the schedule */ 464e009f1b2SAlan Stern qh->link = pqh->link; 46517230acdSAlan Stern wmb(); 466e009f1b2SAlan Stern link_to_new_qh = LINK_TO_QH(qh); 467e009f1b2SAlan Stern pqh->link = link_to_new_qh; 468e009f1b2SAlan Stern 469e009f1b2SAlan Stern /* If this is now the first FSBR QH, link the terminating skeleton 470e009f1b2SAlan Stern * QH to it. */ 471e009f1b2SAlan Stern if (pqh->skel < SKEL_FSBR && qh->skel >= SKEL_FSBR) 472e009f1b2SAlan Stern uhci->skel_term_qh->link = link_to_new_qh; 47317230acdSAlan Stern } 47417230acdSAlan Stern 47517230acdSAlan Stern /* 476dccf4a48SAlan Stern * Put a QH on the schedule in both hardware and software 4771da177e4SLinus Torvalds */ 478dccf4a48SAlan Stern static void uhci_activate_qh(struct uhci_hcd *uhci, struct uhci_qh *qh) 4791da177e4SLinus Torvalds { 480dccf4a48SAlan Stern WARN_ON(list_empty(&qh->queue)); 481dccf4a48SAlan Stern 482dccf4a48SAlan Stern /* Set the element pointer if it isn't set already. 483dccf4a48SAlan Stern * This isn't needed for Isochronous queues, but it doesn't hurt. */ 484dccf4a48SAlan Stern if (qh_element(qh) == UHCI_PTR_TERM) { 485dccf4a48SAlan Stern struct urb_priv *urbp = list_entry(qh->queue.next, 486dccf4a48SAlan Stern struct urb_priv, node); 487dccf4a48SAlan Stern struct uhci_td *td = list_entry(urbp->td_list.next, 488dccf4a48SAlan Stern struct uhci_td, list); 489dccf4a48SAlan Stern 49028b9325eSAlan Stern qh->element = LINK_TO_TD(td); 491dccf4a48SAlan Stern } 492dccf4a48SAlan Stern 49384afddd7SAlan Stern /* Treat the queue as if it has just advanced */ 49484afddd7SAlan Stern qh->wait_expired = 0; 49584afddd7SAlan Stern qh->advance_jiffies = jiffies; 49684afddd7SAlan Stern 497dccf4a48SAlan Stern if (qh->state == QH_STATE_ACTIVE) 4981da177e4SLinus Torvalds return; 499dccf4a48SAlan Stern qh->state = QH_STATE_ACTIVE; 500dccf4a48SAlan Stern 50117230acdSAlan Stern /* Move the QH from its old list to the correct spot in the appropriate 502dccf4a48SAlan Stern * skeleton's list */ 5030ed8fee1SAlan Stern if (qh == uhci->next_qh) 5040ed8fee1SAlan Stern uhci->next_qh = list_entry(qh->node.next, struct uhci_qh, 5050ed8fee1SAlan Stern node); 50617230acdSAlan Stern list_del(&qh->node); 507dccf4a48SAlan Stern 50817230acdSAlan Stern if (qh->skel == SKEL_ISO) 50917230acdSAlan Stern link_iso(uhci, qh); 51017230acdSAlan Stern else if (qh->skel < SKEL_ASYNC) 51117230acdSAlan Stern link_interrupt(uhci, qh); 51217230acdSAlan Stern else 51317230acdSAlan Stern link_async(uhci, qh); 51417230acdSAlan Stern } 51517230acdSAlan Stern 51617230acdSAlan Stern /* 51717230acdSAlan Stern * Unlink a high-period interrupt QH from the schedule 51817230acdSAlan Stern */ 51917230acdSAlan Stern static void unlink_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh) 52017230acdSAlan Stern { 52117230acdSAlan Stern struct uhci_qh *pqh; 52217230acdSAlan Stern 523dccf4a48SAlan Stern pqh = list_entry(qh->node.prev, struct uhci_qh, node); 52417230acdSAlan Stern pqh->link = qh->link; 52517230acdSAlan Stern mb(); 52617230acdSAlan Stern } 52717230acdSAlan Stern 52817230acdSAlan Stern /* 52917230acdSAlan Stern * Unlink a period-1 interrupt or async QH from the schedule 53017230acdSAlan Stern */ 53117230acdSAlan Stern static void unlink_async(struct uhci_hcd *uhci, struct uhci_qh *qh) 53217230acdSAlan Stern { 533e009f1b2SAlan Stern struct uhci_qh *pqh; 53417230acdSAlan Stern __le32 link_to_next_qh = qh->link; 53517230acdSAlan Stern 53617230acdSAlan Stern pqh = list_entry(qh->node.prev, struct uhci_qh, node); 53717230acdSAlan Stern pqh->link = link_to_next_qh; 538e009f1b2SAlan Stern 539e009f1b2SAlan Stern /* If this was the old first FSBR QH, link the terminating skeleton 540e009f1b2SAlan Stern * QH to the next (new first FSBR) QH. */ 541e009f1b2SAlan Stern if (pqh->skel < SKEL_FSBR && qh->skel >= SKEL_FSBR) 542e009f1b2SAlan Stern uhci->skel_term_qh->link = link_to_next_qh; 54317230acdSAlan Stern mb(); 544dccf4a48SAlan Stern } 5451da177e4SLinus Torvalds 5461da177e4SLinus Torvalds /* 547dccf4a48SAlan Stern * Take a QH off the hardware schedule 5481da177e4SLinus Torvalds */ 549dccf4a48SAlan Stern static void uhci_unlink_qh(struct uhci_hcd *uhci, struct uhci_qh *qh) 550dccf4a48SAlan Stern { 551dccf4a48SAlan Stern if (qh->state == QH_STATE_UNLINKING) 552dccf4a48SAlan Stern return; 553dccf4a48SAlan Stern WARN_ON(qh->state != QH_STATE_ACTIVE || !qh->udev); 554dccf4a48SAlan Stern qh->state = QH_STATE_UNLINKING; 5551da177e4SLinus Torvalds 556dccf4a48SAlan Stern /* Unlink the QH from the schedule and record when we did it */ 55717230acdSAlan Stern if (qh->skel == SKEL_ISO) 55817230acdSAlan Stern ; 55917230acdSAlan Stern else if (qh->skel < SKEL_ASYNC) 56017230acdSAlan Stern unlink_interrupt(uhci, qh); 56117230acdSAlan Stern else 56217230acdSAlan Stern unlink_async(uhci, qh); 5631da177e4SLinus Torvalds 5641da177e4SLinus Torvalds uhci_get_current_frame_number(uhci); 565dccf4a48SAlan Stern qh->unlink_frame = uhci->frame_number; 5661da177e4SLinus Torvalds 567dccf4a48SAlan Stern /* Force an interrupt so we know when the QH is fully unlinked */ 568dccf4a48SAlan Stern if (list_empty(&uhci->skel_unlink_qh->node)) 5691da177e4SLinus Torvalds uhci_set_next_interrupt(uhci); 5701da177e4SLinus Torvalds 571dccf4a48SAlan Stern /* Move the QH from its old list to the end of the unlinking list */ 5720ed8fee1SAlan Stern if (qh == uhci->next_qh) 5730ed8fee1SAlan Stern uhci->next_qh = list_entry(qh->node.next, struct uhci_qh, 5740ed8fee1SAlan Stern node); 575dccf4a48SAlan Stern list_move_tail(&qh->node, &uhci->skel_unlink_qh->node); 5761da177e4SLinus Torvalds } 5771da177e4SLinus Torvalds 5781da177e4SLinus Torvalds /* 579dccf4a48SAlan Stern * When we and the controller are through with a QH, it becomes IDLE. 580dccf4a48SAlan Stern * This happens when a QH has been off the schedule (on the unlinking 581dccf4a48SAlan Stern * list) for more than one frame, or when an error occurs while adding 582dccf4a48SAlan Stern * the first URB onto a new QH. 5831da177e4SLinus Torvalds */ 584dccf4a48SAlan Stern static void uhci_make_qh_idle(struct uhci_hcd *uhci, struct uhci_qh *qh) 585dccf4a48SAlan Stern { 586dccf4a48SAlan Stern WARN_ON(qh->state == QH_STATE_ACTIVE); 587dccf4a48SAlan Stern 5880ed8fee1SAlan Stern if (qh == uhci->next_qh) 5890ed8fee1SAlan Stern uhci->next_qh = list_entry(qh->node.next, struct uhci_qh, 5900ed8fee1SAlan Stern node); 591dccf4a48SAlan Stern list_move(&qh->node, &uhci->idle_qh_list); 592dccf4a48SAlan Stern qh->state = QH_STATE_IDLE; 593dccf4a48SAlan Stern 59459e29ed9SAlan Stern /* Now that the QH is idle, its post_td isn't being used */ 59559e29ed9SAlan Stern if (qh->post_td) { 59659e29ed9SAlan Stern uhci_free_td(uhci, qh->post_td); 59759e29ed9SAlan Stern qh->post_td = NULL; 59859e29ed9SAlan Stern } 59959e29ed9SAlan Stern 600dccf4a48SAlan Stern /* If anyone is waiting for a QH to become idle, wake them up */ 601dccf4a48SAlan Stern if (uhci->num_waiting) 602dccf4a48SAlan Stern wake_up_all(&uhci->waitqh); 6031da177e4SLinus Torvalds } 6041da177e4SLinus Torvalds 6053ca2a321SAlan Stern /* 6063ca2a321SAlan Stern * Find the highest existing bandwidth load for a given phase and period. 6073ca2a321SAlan Stern */ 6083ca2a321SAlan Stern static int uhci_highest_load(struct uhci_hcd *uhci, int phase, int period) 6093ca2a321SAlan Stern { 6103ca2a321SAlan Stern int highest_load = uhci->load[phase]; 6113ca2a321SAlan Stern 6123ca2a321SAlan Stern for (phase += period; phase < MAX_PHASE; phase += period) 6133ca2a321SAlan Stern highest_load = max_t(int, highest_load, uhci->load[phase]); 6143ca2a321SAlan Stern return highest_load; 6153ca2a321SAlan Stern } 6163ca2a321SAlan Stern 6173ca2a321SAlan Stern /* 6183ca2a321SAlan Stern * Set qh->phase to the optimal phase for a periodic transfer and 6193ca2a321SAlan Stern * check whether the bandwidth requirement is acceptable. 6203ca2a321SAlan Stern */ 6213ca2a321SAlan Stern static int uhci_check_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh) 6223ca2a321SAlan Stern { 6233ca2a321SAlan Stern int minimax_load; 6243ca2a321SAlan Stern 6253ca2a321SAlan Stern /* Find the optimal phase (unless it is already set) and get 6263ca2a321SAlan Stern * its load value. */ 6273ca2a321SAlan Stern if (qh->phase >= 0) 6283ca2a321SAlan Stern minimax_load = uhci_highest_load(uhci, qh->phase, qh->period); 6293ca2a321SAlan Stern else { 6303ca2a321SAlan Stern int phase, load; 6313ca2a321SAlan Stern int max_phase = min_t(int, MAX_PHASE, qh->period); 6323ca2a321SAlan Stern 6333ca2a321SAlan Stern qh->phase = 0; 6343ca2a321SAlan Stern minimax_load = uhci_highest_load(uhci, qh->phase, qh->period); 6353ca2a321SAlan Stern for (phase = 1; phase < max_phase; ++phase) { 6363ca2a321SAlan Stern load = uhci_highest_load(uhci, phase, qh->period); 6373ca2a321SAlan Stern if (load < minimax_load) { 6383ca2a321SAlan Stern minimax_load = load; 6393ca2a321SAlan Stern qh->phase = phase; 6403ca2a321SAlan Stern } 6413ca2a321SAlan Stern } 6423ca2a321SAlan Stern } 6433ca2a321SAlan Stern 6443ca2a321SAlan Stern /* Maximum allowable periodic bandwidth is 90%, or 900 us per frame */ 6453ca2a321SAlan Stern if (minimax_load + qh->load > 900) { 6463ca2a321SAlan Stern dev_dbg(uhci_dev(uhci), "bandwidth allocation failed: " 6473ca2a321SAlan Stern "period %d, phase %d, %d + %d us\n", 6483ca2a321SAlan Stern qh->period, qh->phase, minimax_load, qh->load); 6493ca2a321SAlan Stern return -ENOSPC; 6503ca2a321SAlan Stern } 6513ca2a321SAlan Stern return 0; 6523ca2a321SAlan Stern } 6533ca2a321SAlan Stern 6543ca2a321SAlan Stern /* 6553ca2a321SAlan Stern * Reserve a periodic QH's bandwidth in the schedule 6563ca2a321SAlan Stern */ 6573ca2a321SAlan Stern static void uhci_reserve_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh) 6583ca2a321SAlan Stern { 6593ca2a321SAlan Stern int i; 6603ca2a321SAlan Stern int load = qh->load; 6613ca2a321SAlan Stern char *p = "??"; 6623ca2a321SAlan Stern 6633ca2a321SAlan Stern for (i = qh->phase; i < MAX_PHASE; i += qh->period) { 6643ca2a321SAlan Stern uhci->load[i] += load; 6653ca2a321SAlan Stern uhci->total_load += load; 6663ca2a321SAlan Stern } 6673ca2a321SAlan Stern uhci_to_hcd(uhci)->self.bandwidth_allocated = 6683ca2a321SAlan Stern uhci->total_load / MAX_PHASE; 6693ca2a321SAlan Stern switch (qh->type) { 6703ca2a321SAlan Stern case USB_ENDPOINT_XFER_INT: 6713ca2a321SAlan Stern ++uhci_to_hcd(uhci)->self.bandwidth_int_reqs; 6723ca2a321SAlan Stern p = "INT"; 6733ca2a321SAlan Stern break; 6743ca2a321SAlan Stern case USB_ENDPOINT_XFER_ISOC: 6753ca2a321SAlan Stern ++uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs; 6763ca2a321SAlan Stern p = "ISO"; 6773ca2a321SAlan Stern break; 6783ca2a321SAlan Stern } 6793ca2a321SAlan Stern qh->bandwidth_reserved = 1; 6803ca2a321SAlan Stern dev_dbg(uhci_dev(uhci), 6813ca2a321SAlan Stern "%s dev %d ep%02x-%s, period %d, phase %d, %d us\n", 6823ca2a321SAlan Stern "reserve", qh->udev->devnum, 6833ca2a321SAlan Stern qh->hep->desc.bEndpointAddress, p, 6843ca2a321SAlan Stern qh->period, qh->phase, load); 6853ca2a321SAlan Stern } 6863ca2a321SAlan Stern 6873ca2a321SAlan Stern /* 6883ca2a321SAlan Stern * Release a periodic QH's bandwidth reservation 6893ca2a321SAlan Stern */ 6903ca2a321SAlan Stern static void uhci_release_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh) 6913ca2a321SAlan Stern { 6923ca2a321SAlan Stern int i; 6933ca2a321SAlan Stern int load = qh->load; 6943ca2a321SAlan Stern char *p = "??"; 6953ca2a321SAlan Stern 6963ca2a321SAlan Stern for (i = qh->phase; i < MAX_PHASE; i += qh->period) { 6973ca2a321SAlan Stern uhci->load[i] -= load; 6983ca2a321SAlan Stern uhci->total_load -= load; 6993ca2a321SAlan Stern } 7003ca2a321SAlan Stern uhci_to_hcd(uhci)->self.bandwidth_allocated = 7013ca2a321SAlan Stern uhci->total_load / MAX_PHASE; 7023ca2a321SAlan Stern switch (qh->type) { 7033ca2a321SAlan Stern case USB_ENDPOINT_XFER_INT: 7043ca2a321SAlan Stern --uhci_to_hcd(uhci)->self.bandwidth_int_reqs; 7053ca2a321SAlan Stern p = "INT"; 7063ca2a321SAlan Stern break; 7073ca2a321SAlan Stern case USB_ENDPOINT_XFER_ISOC: 7083ca2a321SAlan Stern --uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs; 7093ca2a321SAlan Stern p = "ISO"; 7103ca2a321SAlan Stern break; 7113ca2a321SAlan Stern } 7123ca2a321SAlan Stern qh->bandwidth_reserved = 0; 7133ca2a321SAlan Stern dev_dbg(uhci_dev(uhci), 7143ca2a321SAlan Stern "%s dev %d ep%02x-%s, period %d, phase %d, %d us\n", 7153ca2a321SAlan Stern "release", qh->udev->devnum, 7163ca2a321SAlan Stern qh->hep->desc.bEndpointAddress, p, 7173ca2a321SAlan Stern qh->period, qh->phase, load); 7183ca2a321SAlan Stern } 7193ca2a321SAlan Stern 720dccf4a48SAlan Stern static inline struct urb_priv *uhci_alloc_urb_priv(struct uhci_hcd *uhci, 721dccf4a48SAlan Stern struct urb *urb) 7221da177e4SLinus Torvalds { 7231da177e4SLinus Torvalds struct urb_priv *urbp; 7241da177e4SLinus Torvalds 725c3762229SRobert P. J. Day urbp = kmem_cache_zalloc(uhci_up_cachep, GFP_ATOMIC); 7261da177e4SLinus Torvalds if (!urbp) 7271da177e4SLinus Torvalds return NULL; 7281da177e4SLinus Torvalds 7291da177e4SLinus Torvalds urbp->urb = urb; 7301da177e4SLinus Torvalds urb->hcpriv = urbp; 731dccf4a48SAlan Stern 732dccf4a48SAlan Stern INIT_LIST_HEAD(&urbp->node); 733dccf4a48SAlan Stern INIT_LIST_HEAD(&urbp->td_list); 7341da177e4SLinus Torvalds 7351da177e4SLinus Torvalds return urbp; 7361da177e4SLinus Torvalds } 7371da177e4SLinus Torvalds 738dccf4a48SAlan Stern static void uhci_free_urb_priv(struct uhci_hcd *uhci, 739dccf4a48SAlan Stern struct urb_priv *urbp) 7401da177e4SLinus Torvalds { 7411da177e4SLinus Torvalds struct uhci_td *td, *tmp; 7421da177e4SLinus Torvalds 743*5172046dSArjan van de Ven if (!list_empty(&urbp->node)) 744*5172046dSArjan van de Ven dev_WARN(uhci_dev(uhci), "urb %p still on QH's list!\n", 745dccf4a48SAlan Stern urbp->urb); 7461da177e4SLinus Torvalds 7471da177e4SLinus Torvalds list_for_each_entry_safe(td, tmp, &urbp->td_list, list) { 74804538a25SAlan Stern uhci_remove_td_from_urbp(td); 74904538a25SAlan Stern uhci_free_td(uhci, td); 7501da177e4SLinus Torvalds } 7511da177e4SLinus Torvalds 7521da177e4SLinus Torvalds kmem_cache_free(uhci_up_cachep, urbp); 7531da177e4SLinus Torvalds } 7541da177e4SLinus Torvalds 7551da177e4SLinus Torvalds /* 7561da177e4SLinus Torvalds * Map status to standard result codes 7571da177e4SLinus Torvalds * 7581da177e4SLinus Torvalds * <status> is (td_status(td) & 0xF60000), a.k.a. 7591da177e4SLinus Torvalds * uhci_status_bits(td_status(td)). 7601da177e4SLinus Torvalds * Note: <status> does not include the TD_CTRL_NAK bit. 7611da177e4SLinus Torvalds * <dir_out> is True for output TDs and False for input TDs. 7621da177e4SLinus Torvalds */ 7631da177e4SLinus Torvalds static int uhci_map_status(int status, int dir_out) 7641da177e4SLinus Torvalds { 7651da177e4SLinus Torvalds if (!status) 7661da177e4SLinus Torvalds return 0; 7671da177e4SLinus Torvalds if (status & TD_CTRL_BITSTUFF) /* Bitstuff error */ 7681da177e4SLinus Torvalds return -EPROTO; 7691da177e4SLinus Torvalds if (status & TD_CTRL_CRCTIMEO) { /* CRC/Timeout */ 7701da177e4SLinus Torvalds if (dir_out) 7711da177e4SLinus Torvalds return -EPROTO; 7721da177e4SLinus Torvalds else 7731da177e4SLinus Torvalds return -EILSEQ; 7741da177e4SLinus Torvalds } 7751da177e4SLinus Torvalds if (status & TD_CTRL_BABBLE) /* Babble */ 7761da177e4SLinus Torvalds return -EOVERFLOW; 7771da177e4SLinus Torvalds if (status & TD_CTRL_DBUFERR) /* Buffer error */ 7781da177e4SLinus Torvalds return -ENOSR; 7791da177e4SLinus Torvalds if (status & TD_CTRL_STALLED) /* Stalled */ 7801da177e4SLinus Torvalds return -EPIPE; 7811da177e4SLinus Torvalds return 0; 7821da177e4SLinus Torvalds } 7831da177e4SLinus Torvalds 7841da177e4SLinus Torvalds /* 7851da177e4SLinus Torvalds * Control transfers 7861da177e4SLinus Torvalds */ 787dccf4a48SAlan Stern static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb, 788dccf4a48SAlan Stern struct uhci_qh *qh) 7891da177e4SLinus Torvalds { 7901da177e4SLinus Torvalds struct uhci_td *td; 7911da177e4SLinus Torvalds unsigned long destination, status; 792dccf4a48SAlan Stern int maxsze = le16_to_cpu(qh->hep->desc.wMaxPacketSize); 7931da177e4SLinus Torvalds int len = urb->transfer_buffer_length; 7941da177e4SLinus Torvalds dma_addr_t data = urb->transfer_dma; 795dccf4a48SAlan Stern __le32 *plink; 79604538a25SAlan Stern struct urb_priv *urbp = urb->hcpriv; 79717230acdSAlan Stern int skel; 7981da177e4SLinus Torvalds 7991da177e4SLinus Torvalds /* The "pipe" thing contains the destination in bits 8--18 */ 8001da177e4SLinus Torvalds destination = (urb->pipe & PIPE_DEVEP_MASK) | USB_PID_SETUP; 8011da177e4SLinus Torvalds 802af0bb599SAlan Stern /* 3 errors, dummy TD remains inactive */ 803af0bb599SAlan Stern status = uhci_maxerr(3); 8041da177e4SLinus Torvalds if (urb->dev->speed == USB_SPEED_LOW) 8051da177e4SLinus Torvalds status |= TD_CTRL_LS; 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds /* 8081da177e4SLinus Torvalds * Build the TD for the control request setup packet 8091da177e4SLinus Torvalds */ 810af0bb599SAlan Stern td = qh->dummy_td; 81104538a25SAlan Stern uhci_add_td_to_urbp(td, urbp); 812fa346568SAlan Stern uhci_fill_td(td, status, destination | uhci_explen(8), 8131da177e4SLinus Torvalds urb->setup_dma); 814dccf4a48SAlan Stern plink = &td->link; 815af0bb599SAlan Stern status |= TD_CTRL_ACTIVE; 8161da177e4SLinus Torvalds 8171da177e4SLinus Torvalds /* 8181da177e4SLinus Torvalds * If direction is "send", change the packet ID from SETUP (0x2D) 8191da177e4SLinus Torvalds * to OUT (0xE1). Else change it from SETUP to IN (0x69) and 8201da177e4SLinus Torvalds * set Short Packet Detect (SPD) for all data packets. 821e7e7c360SAlan Stern * 822e7e7c360SAlan Stern * 0-length transfers always get treated as "send". 8231da177e4SLinus Torvalds */ 824e7e7c360SAlan Stern if (usb_pipeout(urb->pipe) || len == 0) 8251da177e4SLinus Torvalds destination ^= (USB_PID_SETUP ^ USB_PID_OUT); 8261da177e4SLinus Torvalds else { 8271da177e4SLinus Torvalds destination ^= (USB_PID_SETUP ^ USB_PID_IN); 8281da177e4SLinus Torvalds status |= TD_CTRL_SPD; 8291da177e4SLinus Torvalds } 8301da177e4SLinus Torvalds 8311da177e4SLinus Torvalds /* 832687f5f34SAlan Stern * Build the DATA TDs 8331da177e4SLinus Torvalds */ 8341da177e4SLinus Torvalds while (len > 0) { 835e7e7c360SAlan Stern int pktsze = maxsze; 836e7e7c360SAlan Stern 837e7e7c360SAlan Stern if (len <= pktsze) { /* The last data packet */ 838e7e7c360SAlan Stern pktsze = len; 839e7e7c360SAlan Stern status &= ~TD_CTRL_SPD; 840e7e7c360SAlan Stern } 8411da177e4SLinus Torvalds 8422532178aSAlan Stern td = uhci_alloc_td(uhci); 8431da177e4SLinus Torvalds if (!td) 844af0bb599SAlan Stern goto nomem; 84528b9325eSAlan Stern *plink = LINK_TO_TD(td); 8461da177e4SLinus Torvalds 8471da177e4SLinus Torvalds /* Alternate Data0/1 (start with Data1) */ 8481da177e4SLinus Torvalds destination ^= TD_TOKEN_TOGGLE; 8491da177e4SLinus Torvalds 85004538a25SAlan Stern uhci_add_td_to_urbp(td, urbp); 851fa346568SAlan Stern uhci_fill_td(td, status, destination | uhci_explen(pktsze), 8521da177e4SLinus Torvalds data); 853dccf4a48SAlan Stern plink = &td->link; 8541da177e4SLinus Torvalds 8551da177e4SLinus Torvalds data += pktsze; 8561da177e4SLinus Torvalds len -= pktsze; 8571da177e4SLinus Torvalds } 8581da177e4SLinus Torvalds 8591da177e4SLinus Torvalds /* 8601da177e4SLinus Torvalds * Build the final TD for control status 8611da177e4SLinus Torvalds */ 8622532178aSAlan Stern td = uhci_alloc_td(uhci); 8631da177e4SLinus Torvalds if (!td) 864af0bb599SAlan Stern goto nomem; 86528b9325eSAlan Stern *plink = LINK_TO_TD(td); 8661da177e4SLinus Torvalds 867e7e7c360SAlan Stern /* Change direction for the status transaction */ 868e7e7c360SAlan Stern destination ^= (USB_PID_IN ^ USB_PID_OUT); 8691da177e4SLinus Torvalds destination |= TD_TOKEN_TOGGLE; /* End in Data1 */ 8701da177e4SLinus Torvalds 87104538a25SAlan Stern uhci_add_td_to_urbp(td, urbp); 8721da177e4SLinus Torvalds uhci_fill_td(td, status | TD_CTRL_IOC, 873fa346568SAlan Stern destination | uhci_explen(0), 0); 874af0bb599SAlan Stern plink = &td->link; 875af0bb599SAlan Stern 876af0bb599SAlan Stern /* 877af0bb599SAlan Stern * Build the new dummy TD and activate the old one 878af0bb599SAlan Stern */ 879af0bb599SAlan Stern td = uhci_alloc_td(uhci); 880af0bb599SAlan Stern if (!td) 881af0bb599SAlan Stern goto nomem; 88228b9325eSAlan Stern *plink = LINK_TO_TD(td); 883af0bb599SAlan Stern 884af0bb599SAlan Stern uhci_fill_td(td, 0, USB_PID_OUT | uhci_explen(0), 0); 885af0bb599SAlan Stern wmb(); 886af0bb599SAlan Stern qh->dummy_td->status |= __constant_cpu_to_le32(TD_CTRL_ACTIVE); 887af0bb599SAlan Stern qh->dummy_td = td; 8881da177e4SLinus Torvalds 8891da177e4SLinus Torvalds /* Low-speed transfers get a different queue, and won't hog the bus. 8901da177e4SLinus Torvalds * Also, some devices enumerate better without FSBR; the easiest way 8911da177e4SLinus Torvalds * to do that is to put URBs on the low-speed queue while the device 892630aa3cfSAlan Stern * isn't in the CONFIGURED state. */ 8931da177e4SLinus Torvalds if (urb->dev->speed == USB_SPEED_LOW || 894630aa3cfSAlan Stern urb->dev->state != USB_STATE_CONFIGURED) 89517230acdSAlan Stern skel = SKEL_LS_CONTROL; 8961da177e4SLinus Torvalds else { 89717230acdSAlan Stern skel = SKEL_FS_CONTROL; 89884afddd7SAlan Stern uhci_add_fsbr(uhci, urb); 8991da177e4SLinus Torvalds } 90017230acdSAlan Stern if (qh->state != QH_STATE_ACTIVE) 90117230acdSAlan Stern qh->skel = skel; 90259e29ed9SAlan Stern 90359e29ed9SAlan Stern urb->actual_length = -8; /* Account for the SETUP packet */ 904dccf4a48SAlan Stern return 0; 905af0bb599SAlan Stern 906af0bb599SAlan Stern nomem: 907af0bb599SAlan Stern /* Remove the dummy TD from the td_list so it doesn't get freed */ 90804538a25SAlan Stern uhci_remove_td_from_urbp(qh->dummy_td); 909af0bb599SAlan Stern return -ENOMEM; 9101da177e4SLinus Torvalds } 9111da177e4SLinus Torvalds 9121da177e4SLinus Torvalds /* 9131da177e4SLinus Torvalds * Common submit for bulk and interrupt 9141da177e4SLinus Torvalds */ 915dccf4a48SAlan Stern static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb, 916dccf4a48SAlan Stern struct uhci_qh *qh) 9171da177e4SLinus Torvalds { 9181da177e4SLinus Torvalds struct uhci_td *td; 9191da177e4SLinus Torvalds unsigned long destination, status; 920dccf4a48SAlan Stern int maxsze = le16_to_cpu(qh->hep->desc.wMaxPacketSize); 9211da177e4SLinus Torvalds int len = urb->transfer_buffer_length; 9221da177e4SLinus Torvalds dma_addr_t data = urb->transfer_dma; 923af0bb599SAlan Stern __le32 *plink; 92404538a25SAlan Stern struct urb_priv *urbp = urb->hcpriv; 925af0bb599SAlan Stern unsigned int toggle; 9261da177e4SLinus Torvalds 9271da177e4SLinus Torvalds if (len < 0) 9281da177e4SLinus Torvalds return -EINVAL; 9291da177e4SLinus Torvalds 9301da177e4SLinus Torvalds /* The "pipe" thing contains the destination in bits 8--18 */ 9311da177e4SLinus Torvalds destination = (urb->pipe & PIPE_DEVEP_MASK) | usb_packetid(urb->pipe); 932af0bb599SAlan Stern toggle = usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe), 933af0bb599SAlan Stern usb_pipeout(urb->pipe)); 9341da177e4SLinus Torvalds 935af0bb599SAlan Stern /* 3 errors, dummy TD remains inactive */ 936af0bb599SAlan Stern status = uhci_maxerr(3); 9371da177e4SLinus Torvalds if (urb->dev->speed == USB_SPEED_LOW) 9381da177e4SLinus Torvalds status |= TD_CTRL_LS; 9391da177e4SLinus Torvalds if (usb_pipein(urb->pipe)) 9401da177e4SLinus Torvalds status |= TD_CTRL_SPD; 9411da177e4SLinus Torvalds 9421da177e4SLinus Torvalds /* 943687f5f34SAlan Stern * Build the DATA TDs 9441da177e4SLinus Torvalds */ 945af0bb599SAlan Stern plink = NULL; 946af0bb599SAlan Stern td = qh->dummy_td; 9471da177e4SLinus Torvalds do { /* Allow zero length packets */ 9481da177e4SLinus Torvalds int pktsze = maxsze; 9491da177e4SLinus Torvalds 950dccf4a48SAlan Stern if (len <= pktsze) { /* The last packet */ 9511da177e4SLinus Torvalds pktsze = len; 9521da177e4SLinus Torvalds if (!(urb->transfer_flags & URB_SHORT_NOT_OK)) 9531da177e4SLinus Torvalds status &= ~TD_CTRL_SPD; 9541da177e4SLinus Torvalds } 9551da177e4SLinus Torvalds 956af0bb599SAlan Stern if (plink) { 9572532178aSAlan Stern td = uhci_alloc_td(uhci); 9581da177e4SLinus Torvalds if (!td) 959af0bb599SAlan Stern goto nomem; 96028b9325eSAlan Stern *plink = LINK_TO_TD(td); 961af0bb599SAlan Stern } 96204538a25SAlan Stern uhci_add_td_to_urbp(td, urbp); 963dccf4a48SAlan Stern uhci_fill_td(td, status, 964dccf4a48SAlan Stern destination | uhci_explen(pktsze) | 965af0bb599SAlan Stern (toggle << TD_TOKEN_TOGGLE_SHIFT), 9661da177e4SLinus Torvalds data); 967dccf4a48SAlan Stern plink = &td->link; 968af0bb599SAlan Stern status |= TD_CTRL_ACTIVE; 9691da177e4SLinus Torvalds 9701da177e4SLinus Torvalds data += pktsze; 9711da177e4SLinus Torvalds len -= maxsze; 972af0bb599SAlan Stern toggle ^= 1; 9731da177e4SLinus Torvalds } while (len > 0); 9741da177e4SLinus Torvalds 9751da177e4SLinus Torvalds /* 9761da177e4SLinus Torvalds * URB_ZERO_PACKET means adding a 0-length packet, if direction 9771da177e4SLinus Torvalds * is OUT and the transfer_length was an exact multiple of maxsze, 9781da177e4SLinus Torvalds * hence (len = transfer_length - N * maxsze) == 0 9791da177e4SLinus Torvalds * however, if transfer_length == 0, the zero packet was already 9801da177e4SLinus Torvalds * prepared above. 9811da177e4SLinus Torvalds */ 982dccf4a48SAlan Stern if ((urb->transfer_flags & URB_ZERO_PACKET) && 983dccf4a48SAlan Stern usb_pipeout(urb->pipe) && len == 0 && 984dccf4a48SAlan Stern urb->transfer_buffer_length > 0) { 9852532178aSAlan Stern td = uhci_alloc_td(uhci); 9861da177e4SLinus Torvalds if (!td) 987af0bb599SAlan Stern goto nomem; 98828b9325eSAlan Stern *plink = LINK_TO_TD(td); 9891da177e4SLinus Torvalds 99004538a25SAlan Stern uhci_add_td_to_urbp(td, urbp); 991af0bb599SAlan Stern uhci_fill_td(td, status, 992af0bb599SAlan Stern destination | uhci_explen(0) | 993af0bb599SAlan Stern (toggle << TD_TOKEN_TOGGLE_SHIFT), 9941da177e4SLinus Torvalds data); 995af0bb599SAlan Stern plink = &td->link; 9961da177e4SLinus Torvalds 997af0bb599SAlan Stern toggle ^= 1; 9981da177e4SLinus Torvalds } 9991da177e4SLinus Torvalds 10001da177e4SLinus Torvalds /* Set the interrupt-on-completion flag on the last packet. 10011da177e4SLinus Torvalds * A more-or-less typical 4 KB URB (= size of one memory page) 10021da177e4SLinus Torvalds * will require about 3 ms to transfer; that's a little on the 10031da177e4SLinus Torvalds * fast side but not enough to justify delaying an interrupt 10041da177e4SLinus Torvalds * more than 2 or 3 URBs, so we will ignore the URB_NO_INTERRUPT 10051da177e4SLinus Torvalds * flag setting. */ 1006dccf4a48SAlan Stern td->status |= __constant_cpu_to_le32(TD_CTRL_IOC); 10071da177e4SLinus Torvalds 1008af0bb599SAlan Stern /* 1009af0bb599SAlan Stern * Build the new dummy TD and activate the old one 1010af0bb599SAlan Stern */ 1011af0bb599SAlan Stern td = uhci_alloc_td(uhci); 1012af0bb599SAlan Stern if (!td) 1013af0bb599SAlan Stern goto nomem; 101428b9325eSAlan Stern *plink = LINK_TO_TD(td); 1015af0bb599SAlan Stern 1016af0bb599SAlan Stern uhci_fill_td(td, 0, USB_PID_OUT | uhci_explen(0), 0); 1017af0bb599SAlan Stern wmb(); 1018af0bb599SAlan Stern qh->dummy_td->status |= __constant_cpu_to_le32(TD_CTRL_ACTIVE); 1019af0bb599SAlan Stern qh->dummy_td = td; 1020af0bb599SAlan Stern 1021af0bb599SAlan Stern usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), 1022af0bb599SAlan Stern usb_pipeout(urb->pipe), toggle); 1023dccf4a48SAlan Stern return 0; 1024af0bb599SAlan Stern 1025af0bb599SAlan Stern nomem: 1026af0bb599SAlan Stern /* Remove the dummy TD from the td_list so it doesn't get freed */ 102704538a25SAlan Stern uhci_remove_td_from_urbp(qh->dummy_td); 1028af0bb599SAlan Stern return -ENOMEM; 10291da177e4SLinus Torvalds } 10301da177e4SLinus Torvalds 103117230acdSAlan Stern static int uhci_submit_bulk(struct uhci_hcd *uhci, struct urb *urb, 1032dccf4a48SAlan Stern struct uhci_qh *qh) 10331da177e4SLinus Torvalds { 10341da177e4SLinus Torvalds int ret; 10351da177e4SLinus Torvalds 10361da177e4SLinus Torvalds /* Can't have low-speed bulk transfers */ 10371da177e4SLinus Torvalds if (urb->dev->speed == USB_SPEED_LOW) 10381da177e4SLinus Torvalds return -EINVAL; 10391da177e4SLinus Torvalds 104017230acdSAlan Stern if (qh->state != QH_STATE_ACTIVE) 104117230acdSAlan Stern qh->skel = SKEL_BULK; 1042dccf4a48SAlan Stern ret = uhci_submit_common(uhci, urb, qh); 1043dccf4a48SAlan Stern if (ret == 0) 104484afddd7SAlan Stern uhci_add_fsbr(uhci, urb); 10451da177e4SLinus Torvalds return ret; 10461da177e4SLinus Torvalds } 10471da177e4SLinus Torvalds 1048caf3827aSAlan Stern static int uhci_submit_interrupt(struct uhci_hcd *uhci, struct urb *urb, 1049dccf4a48SAlan Stern struct uhci_qh *qh) 10501da177e4SLinus Torvalds { 10513ca2a321SAlan Stern int ret; 1052caf3827aSAlan Stern 1053dccf4a48SAlan Stern /* USB 1.1 interrupt transfers only involve one packet per interval. 1054dccf4a48SAlan Stern * Drivers can submit URBs of any length, but longer ones will need 1055dccf4a48SAlan Stern * multiple intervals to complete. 10561da177e4SLinus Torvalds */ 1057caf3827aSAlan Stern 10583ca2a321SAlan Stern if (!qh->bandwidth_reserved) { 10593ca2a321SAlan Stern int exponent; 10603ca2a321SAlan Stern 1061caf3827aSAlan Stern /* Figure out which power-of-two queue to use */ 1062caf3827aSAlan Stern for (exponent = 7; exponent >= 0; --exponent) { 1063caf3827aSAlan Stern if ((1 << exponent) <= urb->interval) 1064caf3827aSAlan Stern break; 1065caf3827aSAlan Stern } 1066caf3827aSAlan Stern if (exponent < 0) 1067caf3827aSAlan Stern return -EINVAL; 10683ca2a321SAlan Stern qh->period = 1 << exponent; 106917230acdSAlan Stern qh->skel = SKEL_INDEX(exponent); 1070caf3827aSAlan Stern 10713ca2a321SAlan Stern /* For now, interrupt phase is fixed by the layout 10723ca2a321SAlan Stern * of the QH lists. */ 10733ca2a321SAlan Stern qh->phase = (qh->period / 2) & (MAX_PHASE - 1); 10743ca2a321SAlan Stern ret = uhci_check_bandwidth(uhci, qh); 10753ca2a321SAlan Stern if (ret) 10763ca2a321SAlan Stern return ret; 10773ca2a321SAlan Stern } else if (qh->period > urb->interval) 10783ca2a321SAlan Stern return -EINVAL; /* Can't decrease the period */ 10793ca2a321SAlan Stern 10803ca2a321SAlan Stern ret = uhci_submit_common(uhci, urb, qh); 10813ca2a321SAlan Stern if (ret == 0) { 10823ca2a321SAlan Stern urb->interval = qh->period; 10833ca2a321SAlan Stern if (!qh->bandwidth_reserved) 10843ca2a321SAlan Stern uhci_reserve_bandwidth(uhci, qh); 10853ca2a321SAlan Stern } 10863ca2a321SAlan Stern return ret; 10871da177e4SLinus Torvalds } 10881da177e4SLinus Torvalds 10891da177e4SLinus Torvalds /* 1090b1869000SAlan Stern * Fix up the data structures following a short transfer 1091b1869000SAlan Stern */ 1092b1869000SAlan Stern static int uhci_fixup_short_transfer(struct uhci_hcd *uhci, 109359e29ed9SAlan Stern struct uhci_qh *qh, struct urb_priv *urbp) 1094b1869000SAlan Stern { 1095b1869000SAlan Stern struct uhci_td *td; 109659e29ed9SAlan Stern struct list_head *tmp; 109759e29ed9SAlan Stern int ret; 1098b1869000SAlan Stern 1099b1869000SAlan Stern td = list_entry(urbp->td_list.prev, struct uhci_td, list); 1100b1869000SAlan Stern if (qh->type == USB_ENDPOINT_XFER_CONTROL) { 1101b1869000SAlan Stern 1102b1869000SAlan Stern /* When a control transfer is short, we have to restart 1103b1869000SAlan Stern * the queue at the status stage transaction, which is 1104b1869000SAlan Stern * the last TD. */ 110559e29ed9SAlan Stern WARN_ON(list_empty(&urbp->td_list)); 110628b9325eSAlan Stern qh->element = LINK_TO_TD(td); 110759e29ed9SAlan Stern tmp = td->list.prev; 1108b1869000SAlan Stern ret = -EINPROGRESS; 1109b1869000SAlan Stern 111059e29ed9SAlan Stern } else { 1111b1869000SAlan Stern 1112b1869000SAlan Stern /* When a bulk/interrupt transfer is short, we have to 1113b1869000SAlan Stern * fix up the toggles of the following URBs on the queue 1114b1869000SAlan Stern * before restarting the queue at the next URB. */ 111559e29ed9SAlan Stern qh->initial_toggle = uhci_toggle(td_token(qh->post_td)) ^ 1; 1116b1869000SAlan Stern uhci_fixup_toggles(qh, 1); 1117b1869000SAlan Stern 111859e29ed9SAlan Stern if (list_empty(&urbp->td_list)) 111959e29ed9SAlan Stern td = qh->post_td; 1120b1869000SAlan Stern qh->element = td->link; 112159e29ed9SAlan Stern tmp = urbp->td_list.prev; 112259e29ed9SAlan Stern ret = 0; 1123b1869000SAlan Stern } 1124b1869000SAlan Stern 112559e29ed9SAlan Stern /* Remove all the TDs we skipped over, from tmp back to the start */ 112659e29ed9SAlan Stern while (tmp != &urbp->td_list) { 112759e29ed9SAlan Stern td = list_entry(tmp, struct uhci_td, list); 112859e29ed9SAlan Stern tmp = tmp->prev; 112959e29ed9SAlan Stern 113004538a25SAlan Stern uhci_remove_td_from_urbp(td); 113104538a25SAlan Stern uhci_free_td(uhci, td); 113259e29ed9SAlan Stern } 1133b1869000SAlan Stern return ret; 1134b1869000SAlan Stern } 1135b1869000SAlan Stern 1136b1869000SAlan Stern /* 1137b1869000SAlan Stern * Common result for control, bulk, and interrupt 1138b1869000SAlan Stern */ 1139b1869000SAlan Stern static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb) 1140b1869000SAlan Stern { 1141b1869000SAlan Stern struct urb_priv *urbp = urb->hcpriv; 1142b1869000SAlan Stern struct uhci_qh *qh = urbp->qh; 114359e29ed9SAlan Stern struct uhci_td *td, *tmp; 1144b1869000SAlan Stern unsigned status; 1145b1869000SAlan Stern int ret = 0; 1146b1869000SAlan Stern 114759e29ed9SAlan Stern list_for_each_entry_safe(td, tmp, &urbp->td_list, list) { 1148b1869000SAlan Stern unsigned int ctrlstat; 1149b1869000SAlan Stern int len; 1150b1869000SAlan Stern 1151b1869000SAlan Stern ctrlstat = td_status(td); 1152b1869000SAlan Stern status = uhci_status_bits(ctrlstat); 1153b1869000SAlan Stern if (status & TD_CTRL_ACTIVE) 1154b1869000SAlan Stern return -EINPROGRESS; 1155b1869000SAlan Stern 1156b1869000SAlan Stern len = uhci_actual_length(ctrlstat); 1157b1869000SAlan Stern urb->actual_length += len; 1158b1869000SAlan Stern 1159b1869000SAlan Stern if (status) { 1160b1869000SAlan Stern ret = uhci_map_status(status, 1161b1869000SAlan Stern uhci_packetout(td_token(td))); 1162b1869000SAlan Stern if ((debug == 1 && ret != -EPIPE) || debug > 1) { 1163b1869000SAlan Stern /* Some debugging code */ 1164be3cbc5fSDavid Brownell dev_dbg(&urb->dev->dev, 1165b1869000SAlan Stern "%s: failed with status %x\n", 1166441b62c1SHarvey Harrison __func__, status); 1167b1869000SAlan Stern 1168b1869000SAlan Stern if (debug > 1 && errbuf) { 1169b1869000SAlan Stern /* Print the chain for debugging */ 1170e009f1b2SAlan Stern uhci_show_qh(uhci, urbp->qh, errbuf, 1171b1869000SAlan Stern ERRBUF_LEN, 0); 1172b1869000SAlan Stern lprintk(errbuf); 1173b1869000SAlan Stern } 1174b1869000SAlan Stern } 1175b1869000SAlan Stern 1176e7e7c360SAlan Stern /* Did we receive a short packet? */ 1177b1869000SAlan Stern } else if (len < uhci_expected_length(td_token(td))) { 1178b1869000SAlan Stern 1179e7e7c360SAlan Stern /* For control transfers, go to the status TD if 1180e7e7c360SAlan Stern * this isn't already the last data TD */ 1181e7e7c360SAlan Stern if (qh->type == USB_ENDPOINT_XFER_CONTROL) { 1182e7e7c360SAlan Stern if (td->list.next != urbp->td_list.prev) 1183e7e7c360SAlan Stern ret = 1; 1184e7e7c360SAlan Stern } 1185e7e7c360SAlan Stern 1186e7e7c360SAlan Stern /* For bulk and interrupt, this may be an error */ 1187e7e7c360SAlan Stern else if (urb->transfer_flags & URB_SHORT_NOT_OK) 1188b1869000SAlan Stern ret = -EREMOTEIO; 1189f443ddf1SAlan Stern 1190f443ddf1SAlan Stern /* Fixup needed only if this isn't the URB's last TD */ 1191f443ddf1SAlan Stern else if (&td->list != urbp->td_list.prev) 1192b1869000SAlan Stern ret = 1; 1193b1869000SAlan Stern } 1194b1869000SAlan Stern 119504538a25SAlan Stern uhci_remove_td_from_urbp(td); 119659e29ed9SAlan Stern if (qh->post_td) 119704538a25SAlan Stern uhci_free_td(uhci, qh->post_td); 119859e29ed9SAlan Stern qh->post_td = td; 119959e29ed9SAlan Stern 1200b1869000SAlan Stern if (ret != 0) 1201b1869000SAlan Stern goto err; 1202b1869000SAlan Stern } 1203b1869000SAlan Stern return ret; 1204b1869000SAlan Stern 1205b1869000SAlan Stern err: 1206b1869000SAlan Stern if (ret < 0) { 1207b1869000SAlan Stern /* Note that the queue has stopped and save 1208b1869000SAlan Stern * the next toggle value */ 1209b1869000SAlan Stern qh->element = UHCI_PTR_TERM; 1210b1869000SAlan Stern qh->is_stopped = 1; 1211b1869000SAlan Stern qh->needs_fixup = (qh->type != USB_ENDPOINT_XFER_CONTROL); 1212b1869000SAlan Stern qh->initial_toggle = uhci_toggle(td_token(td)) ^ 1213b1869000SAlan Stern (ret == -EREMOTEIO); 1214b1869000SAlan Stern 1215b1869000SAlan Stern } else /* Short packet received */ 121659e29ed9SAlan Stern ret = uhci_fixup_short_transfer(uhci, qh, urbp); 1217b1869000SAlan Stern return ret; 1218b1869000SAlan Stern } 1219b1869000SAlan Stern 1220b1869000SAlan Stern /* 12211da177e4SLinus Torvalds * Isochronous transfers 12221da177e4SLinus Torvalds */ 1223dccf4a48SAlan Stern static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb, 1224dccf4a48SAlan Stern struct uhci_qh *qh) 12251da177e4SLinus Torvalds { 1226dccf4a48SAlan Stern struct uhci_td *td = NULL; /* Since urb->number_of_packets > 0 */ 12270ed8fee1SAlan Stern int i, frame; 1228dccf4a48SAlan Stern unsigned long destination, status; 1229b81d3436SAlan Stern struct urb_priv *urbp = (struct urb_priv *) urb->hcpriv; 12301da177e4SLinus Torvalds 1231caf3827aSAlan Stern /* Values must not be too big (could overflow below) */ 1232caf3827aSAlan Stern if (urb->interval >= UHCI_NUMFRAMES || 1233caf3827aSAlan Stern urb->number_of_packets >= UHCI_NUMFRAMES) 1234caf3827aSAlan Stern return -EFBIG; 1235caf3827aSAlan Stern 1236caf3827aSAlan Stern /* Check the period and figure out the starting frame number */ 12373ca2a321SAlan Stern if (!qh->bandwidth_reserved) { 12383ca2a321SAlan Stern qh->period = urb->interval; 1239caf3827aSAlan Stern if (urb->transfer_flags & URB_ISO_ASAP) { 12403ca2a321SAlan Stern qh->phase = -1; /* Find the best phase */ 12413ca2a321SAlan Stern i = uhci_check_bandwidth(uhci, qh); 12423ca2a321SAlan Stern if (i) 12433ca2a321SAlan Stern return i; 12443ca2a321SAlan Stern 12453ca2a321SAlan Stern /* Allow a little time to allocate the TDs */ 1246c8155cc5SAlan Stern uhci_get_current_frame_number(uhci); 12473ca2a321SAlan Stern frame = uhci->frame_number + 10; 12483ca2a321SAlan Stern 12493ca2a321SAlan Stern /* Move forward to the first frame having the 12503ca2a321SAlan Stern * correct phase */ 12513ca2a321SAlan Stern urb->start_frame = frame + ((qh->phase - frame) & 12523ca2a321SAlan Stern (qh->period - 1)); 1253caf3827aSAlan Stern } else { 1254c8155cc5SAlan Stern i = urb->start_frame - uhci->last_iso_frame; 1255caf3827aSAlan Stern if (i <= 0 || i >= UHCI_NUMFRAMES) 1256caf3827aSAlan Stern return -EINVAL; 12573ca2a321SAlan Stern qh->phase = urb->start_frame & (qh->period - 1); 12583ca2a321SAlan Stern i = uhci_check_bandwidth(uhci, qh); 12593ca2a321SAlan Stern if (i) 12603ca2a321SAlan Stern return i; 1261caf3827aSAlan Stern } 12623ca2a321SAlan Stern 1263caf3827aSAlan Stern } else if (qh->period != urb->interval) { 1264caf3827aSAlan Stern return -EINVAL; /* Can't change the period */ 1265caf3827aSAlan Stern 12667898ffc5SAlan Stern } else { 12677898ffc5SAlan Stern /* Find the next unused frame */ 1268caf3827aSAlan Stern if (list_empty(&qh->queue)) { 1269c8155cc5SAlan Stern frame = qh->iso_frame; 1270caf3827aSAlan Stern } else { 1271caf3827aSAlan Stern struct urb *lurb; 1272caf3827aSAlan Stern 1273caf3827aSAlan Stern lurb = list_entry(qh->queue.prev, 1274caf3827aSAlan Stern struct urb_priv, node)->urb; 1275caf3827aSAlan Stern frame = lurb->start_frame + 1276caf3827aSAlan Stern lurb->number_of_packets * 1277caf3827aSAlan Stern lurb->interval; 1278caf3827aSAlan Stern } 12797898ffc5SAlan Stern if (urb->transfer_flags & URB_ISO_ASAP) { 12807898ffc5SAlan Stern /* Skip some frames if necessary to insure 12817898ffc5SAlan Stern * the start frame is in the future. 12827898ffc5SAlan Stern */ 12837898ffc5SAlan Stern uhci_get_current_frame_number(uhci); 12847898ffc5SAlan Stern if (uhci_frame_before_eq(frame, uhci->frame_number)) { 12857898ffc5SAlan Stern frame = uhci->frame_number + 1; 12867898ffc5SAlan Stern frame += ((qh->phase - frame) & 12877898ffc5SAlan Stern (qh->period - 1)); 12887898ffc5SAlan Stern } 12897898ffc5SAlan Stern } /* Otherwise pick up where the last URB leaves off */ 1290caf3827aSAlan Stern urb->start_frame = frame; 1291caf3827aSAlan Stern } 1292caf3827aSAlan Stern 1293caf3827aSAlan Stern /* Make sure we won't have to go too far into the future */ 1294c8155cc5SAlan Stern if (uhci_frame_before_eq(uhci->last_iso_frame + UHCI_NUMFRAMES, 1295caf3827aSAlan Stern urb->start_frame + urb->number_of_packets * 1296caf3827aSAlan Stern urb->interval)) 12970ed8fee1SAlan Stern return -EFBIG; 12980ed8fee1SAlan Stern 12991da177e4SLinus Torvalds status = TD_CTRL_ACTIVE | TD_CTRL_IOS; 13001da177e4SLinus Torvalds destination = (urb->pipe & PIPE_DEVEP_MASK) | usb_packetid(urb->pipe); 13011da177e4SLinus Torvalds 1302b81d3436SAlan Stern for (i = 0; i < urb->number_of_packets; i++) { 13032532178aSAlan Stern td = uhci_alloc_td(uhci); 13041da177e4SLinus Torvalds if (!td) 13051da177e4SLinus Torvalds return -ENOMEM; 13061da177e4SLinus Torvalds 130704538a25SAlan Stern uhci_add_td_to_urbp(td, urbp); 1308dccf4a48SAlan Stern uhci_fill_td(td, status, destination | 1309dccf4a48SAlan Stern uhci_explen(urb->iso_frame_desc[i].length), 1310dccf4a48SAlan Stern urb->transfer_dma + 1311dccf4a48SAlan Stern urb->iso_frame_desc[i].offset); 1312b81d3436SAlan Stern } 13131da177e4SLinus Torvalds 1314dccf4a48SAlan Stern /* Set the interrupt-on-completion flag on the last packet. */ 1315dccf4a48SAlan Stern td->status |= __constant_cpu_to_le32(TD_CTRL_IOC); 1316dccf4a48SAlan Stern 1317dccf4a48SAlan Stern /* Add the TDs to the frame list */ 1318b81d3436SAlan Stern frame = urb->start_frame; 1319b81d3436SAlan Stern list_for_each_entry(td, &urbp->td_list, list) { 1320dccf4a48SAlan Stern uhci_insert_td_in_frame_list(uhci, td, frame); 1321c8155cc5SAlan Stern frame += qh->period; 1322c8155cc5SAlan Stern } 1323c8155cc5SAlan Stern 1324c8155cc5SAlan Stern if (list_empty(&qh->queue)) { 1325c8155cc5SAlan Stern qh->iso_packet_desc = &urb->iso_frame_desc[0]; 1326c8155cc5SAlan Stern qh->iso_frame = urb->start_frame; 13271da177e4SLinus Torvalds } 13281da177e4SLinus Torvalds 132917230acdSAlan Stern qh->skel = SKEL_ISO; 13303ca2a321SAlan Stern if (!qh->bandwidth_reserved) 13313ca2a321SAlan Stern uhci_reserve_bandwidth(uhci, qh); 1332dccf4a48SAlan Stern return 0; 13331da177e4SLinus Torvalds } 13341da177e4SLinus Torvalds 13351da177e4SLinus Torvalds static int uhci_result_isochronous(struct uhci_hcd *uhci, struct urb *urb) 13361da177e4SLinus Torvalds { 1337c8155cc5SAlan Stern struct uhci_td *td, *tmp; 1338c8155cc5SAlan Stern struct urb_priv *urbp = urb->hcpriv; 1339c8155cc5SAlan Stern struct uhci_qh *qh = urbp->qh; 1340c8155cc5SAlan Stern 1341c8155cc5SAlan Stern list_for_each_entry_safe(td, tmp, &urbp->td_list, list) { 1342c8155cc5SAlan Stern unsigned int ctrlstat; 13431da177e4SLinus Torvalds int status; 13441da177e4SLinus Torvalds int actlength; 13451da177e4SLinus Torvalds 1346c8155cc5SAlan Stern if (uhci_frame_before_eq(uhci->cur_iso_frame, qh->iso_frame)) 13471da177e4SLinus Torvalds return -EINPROGRESS; 13481da177e4SLinus Torvalds 1349c8155cc5SAlan Stern uhci_remove_tds_from_frame(uhci, qh->iso_frame); 13501da177e4SLinus Torvalds 1351c8155cc5SAlan Stern ctrlstat = td_status(td); 1352c8155cc5SAlan Stern if (ctrlstat & TD_CTRL_ACTIVE) { 1353c8155cc5SAlan Stern status = -EXDEV; /* TD was added too late? */ 1354c8155cc5SAlan Stern } else { 13551da177e4SLinus Torvalds status = uhci_map_status(uhci_status_bits(ctrlstat), 13561da177e4SLinus Torvalds usb_pipeout(urb->pipe)); 1357c8155cc5SAlan Stern actlength = uhci_actual_length(ctrlstat); 1358c8155cc5SAlan Stern 1359c8155cc5SAlan Stern urb->actual_length += actlength; 1360c8155cc5SAlan Stern qh->iso_packet_desc->actual_length = actlength; 1361c8155cc5SAlan Stern qh->iso_packet_desc->status = status; 1362c8155cc5SAlan Stern } 1363ee7d1f3fSAlan Stern if (status) 13641da177e4SLinus Torvalds urb->error_count++; 13651da177e4SLinus Torvalds 1366c8155cc5SAlan Stern uhci_remove_td_from_urbp(td); 1367c8155cc5SAlan Stern uhci_free_td(uhci, td); 1368c8155cc5SAlan Stern qh->iso_frame += qh->period; 1369c8155cc5SAlan Stern ++qh->iso_packet_desc; 13701da177e4SLinus Torvalds } 1371ee7d1f3fSAlan Stern return 0; 13721da177e4SLinus Torvalds } 13731da177e4SLinus Torvalds 13741da177e4SLinus Torvalds static int uhci_urb_enqueue(struct usb_hcd *hcd, 137555016f10SAl Viro struct urb *urb, gfp_t mem_flags) 13761da177e4SLinus Torvalds { 13771da177e4SLinus Torvalds int ret; 13781da177e4SLinus Torvalds struct uhci_hcd *uhci = hcd_to_uhci(hcd); 13791da177e4SLinus Torvalds unsigned long flags; 1380dccf4a48SAlan Stern struct urb_priv *urbp; 1381dccf4a48SAlan Stern struct uhci_qh *qh; 13821da177e4SLinus Torvalds 13831da177e4SLinus Torvalds spin_lock_irqsave(&uhci->lock, flags); 13841da177e4SLinus Torvalds 1385e9df41c5SAlan Stern ret = usb_hcd_link_urb_to_ep(hcd, urb); 1386e9df41c5SAlan Stern if (ret) 1387e9df41c5SAlan Stern goto done_not_linked; 13881da177e4SLinus Torvalds 13891da177e4SLinus Torvalds ret = -ENOMEM; 1390dccf4a48SAlan Stern urbp = uhci_alloc_urb_priv(uhci, urb); 1391dccf4a48SAlan Stern if (!urbp) 1392dccf4a48SAlan Stern goto done; 1393dccf4a48SAlan Stern 1394e9df41c5SAlan Stern if (urb->ep->hcpriv) 1395e9df41c5SAlan Stern qh = urb->ep->hcpriv; 1396dccf4a48SAlan Stern else { 1397e9df41c5SAlan Stern qh = uhci_alloc_qh(uhci, urb->dev, urb->ep); 1398dccf4a48SAlan Stern if (!qh) 1399dccf4a48SAlan Stern goto err_no_qh; 14001da177e4SLinus Torvalds } 1401dccf4a48SAlan Stern urbp->qh = qh; 14021da177e4SLinus Torvalds 14034de7d2c2SAlan Stern switch (qh->type) { 14044de7d2c2SAlan Stern case USB_ENDPOINT_XFER_CONTROL: 1405dccf4a48SAlan Stern ret = uhci_submit_control(uhci, urb, qh); 1406dccf4a48SAlan Stern break; 14074de7d2c2SAlan Stern case USB_ENDPOINT_XFER_BULK: 1408dccf4a48SAlan Stern ret = uhci_submit_bulk(uhci, urb, qh); 14091da177e4SLinus Torvalds break; 14104de7d2c2SAlan Stern case USB_ENDPOINT_XFER_INT: 1411dccf4a48SAlan Stern ret = uhci_submit_interrupt(uhci, urb, qh); 14121da177e4SLinus Torvalds break; 14134de7d2c2SAlan Stern case USB_ENDPOINT_XFER_ISOC: 1414c8155cc5SAlan Stern urb->error_count = 0; 1415dccf4a48SAlan Stern ret = uhci_submit_isochronous(uhci, urb, qh); 14161da177e4SLinus Torvalds break; 14171da177e4SLinus Torvalds } 1418dccf4a48SAlan Stern if (ret != 0) 1419dccf4a48SAlan Stern goto err_submit_failed; 14201da177e4SLinus Torvalds 1421dccf4a48SAlan Stern /* Add this URB to the QH */ 1422dccf4a48SAlan Stern urbp->qh = qh; 1423dccf4a48SAlan Stern list_add_tail(&urbp->node, &qh->queue); 14241da177e4SLinus Torvalds 1425dccf4a48SAlan Stern /* If the new URB is the first and only one on this QH then either 1426dccf4a48SAlan Stern * the QH is new and idle or else it's unlinked and waiting to 14272775562aSAlan Stern * become idle, so we can activate it right away. But only if the 14282775562aSAlan Stern * queue isn't stopped. */ 142984afddd7SAlan Stern if (qh->queue.next == &urbp->node && !qh->is_stopped) { 1430dccf4a48SAlan Stern uhci_activate_qh(uhci, qh); 1431c5e3b741SAlan Stern uhci_urbp_wants_fsbr(uhci, urbp); 143284afddd7SAlan Stern } 1433dccf4a48SAlan Stern goto done; 1434dccf4a48SAlan Stern 1435dccf4a48SAlan Stern err_submit_failed: 1436dccf4a48SAlan Stern if (qh->state == QH_STATE_IDLE) 1437dccf4a48SAlan Stern uhci_make_qh_idle(uhci, qh); /* Reclaim unused QH */ 1438dccf4a48SAlan Stern err_no_qh: 1439dccf4a48SAlan Stern uhci_free_urb_priv(uhci, urbp); 1440dccf4a48SAlan Stern done: 1441e9df41c5SAlan Stern if (ret) 1442e9df41c5SAlan Stern usb_hcd_unlink_urb_from_ep(hcd, urb); 1443e9df41c5SAlan Stern done_not_linked: 14441da177e4SLinus Torvalds spin_unlock_irqrestore(&uhci->lock, flags); 14451da177e4SLinus Torvalds return ret; 14461da177e4SLinus Torvalds } 14471da177e4SLinus Torvalds 1448e9df41c5SAlan Stern static int uhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) 14491da177e4SLinus Torvalds { 14501da177e4SLinus Torvalds struct uhci_hcd *uhci = hcd_to_uhci(hcd); 14511da177e4SLinus Torvalds unsigned long flags; 145210b8e47dSAlan Stern struct uhci_qh *qh; 1453e9df41c5SAlan Stern int rc; 14541da177e4SLinus Torvalds 14551da177e4SLinus Torvalds spin_lock_irqsave(&uhci->lock, flags); 1456e9df41c5SAlan Stern rc = usb_hcd_check_unlink_urb(hcd, urb, status); 1457e9df41c5SAlan Stern if (rc) 14581da177e4SLinus Torvalds goto done; 1459e9df41c5SAlan Stern 1460e9df41c5SAlan Stern qh = ((struct urb_priv *) urb->hcpriv)->qh; 14611da177e4SLinus Torvalds 1462dccf4a48SAlan Stern /* Remove Isochronous TDs from the frame list ASAP */ 146310b8e47dSAlan Stern if (qh->type == USB_ENDPOINT_XFER_ISOC) { 1464dccf4a48SAlan Stern uhci_unlink_isochronous_tds(uhci, urb); 146510b8e47dSAlan Stern mb(); 146610b8e47dSAlan Stern 146710b8e47dSAlan Stern /* If the URB has already started, update the QH unlink time */ 146810b8e47dSAlan Stern uhci_get_current_frame_number(uhci); 146910b8e47dSAlan Stern if (uhci_frame_before_eq(urb->start_frame, uhci->frame_number)) 147010b8e47dSAlan Stern qh->unlink_frame = uhci->frame_number; 147110b8e47dSAlan Stern } 147210b8e47dSAlan Stern 147310b8e47dSAlan Stern uhci_unlink_qh(uhci, qh); 14741da177e4SLinus Torvalds 14751da177e4SLinus Torvalds done: 14761da177e4SLinus Torvalds spin_unlock_irqrestore(&uhci->lock, flags); 1477e9df41c5SAlan Stern return rc; 14781da177e4SLinus Torvalds } 14791da177e4SLinus Torvalds 14800ed8fee1SAlan Stern /* 14810ed8fee1SAlan Stern * Finish unlinking an URB and give it back 14820ed8fee1SAlan Stern */ 14830ed8fee1SAlan Stern static void uhci_giveback_urb(struct uhci_hcd *uhci, struct uhci_qh *qh, 14844a00027dSAlan Stern struct urb *urb, int status) 14850ed8fee1SAlan Stern __releases(uhci->lock) 14860ed8fee1SAlan Stern __acquires(uhci->lock) 14871da177e4SLinus Torvalds { 14881da177e4SLinus Torvalds struct urb_priv *urbp = (struct urb_priv *) urb->hcpriv; 14891da177e4SLinus Torvalds 1490e7e7c360SAlan Stern if (qh->type == USB_ENDPOINT_XFER_CONTROL) { 1491e7e7c360SAlan Stern 1492e7e7c360SAlan Stern /* urb->actual_length < 0 means the setup transaction didn't 1493e7e7c360SAlan Stern * complete successfully. Either it failed or the URB was 1494e7e7c360SAlan Stern * unlinked first. Regardless, don't confuse people with a 1495e7e7c360SAlan Stern * negative length. */ 1496e7e7c360SAlan Stern urb->actual_length = max(urb->actual_length, 0); 1497e7e7c360SAlan Stern } 1498e7e7c360SAlan Stern 1499c8155cc5SAlan Stern /* When giving back the first URB in an Isochronous queue, 1500c8155cc5SAlan Stern * reinitialize the QH's iso-related members for the next URB. */ 1501e7e7c360SAlan Stern else if (qh->type == USB_ENDPOINT_XFER_ISOC && 1502c8155cc5SAlan Stern urbp->node.prev == &qh->queue && 1503c8155cc5SAlan Stern urbp->node.next != &qh->queue) { 1504c8155cc5SAlan Stern struct urb *nurb = list_entry(urbp->node.next, 1505c8155cc5SAlan Stern struct urb_priv, node)->urb; 1506c8155cc5SAlan Stern 1507c8155cc5SAlan Stern qh->iso_packet_desc = &nurb->iso_frame_desc[0]; 1508c8155cc5SAlan Stern qh->iso_frame = nurb->start_frame; 1509c8155cc5SAlan Stern } 15101da177e4SLinus Torvalds 15110ed8fee1SAlan Stern /* Take the URB off the QH's queue. If the queue is now empty, 15120ed8fee1SAlan Stern * this is a perfect time for a toggle fixup. */ 15130ed8fee1SAlan Stern list_del_init(&urbp->node); 15140ed8fee1SAlan Stern if (list_empty(&qh->queue) && qh->needs_fixup) { 15150ed8fee1SAlan Stern usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), 15160ed8fee1SAlan Stern usb_pipeout(urb->pipe), qh->initial_toggle); 15170ed8fee1SAlan Stern qh->needs_fixup = 0; 15180ed8fee1SAlan Stern } 15190ed8fee1SAlan Stern 15200ed8fee1SAlan Stern uhci_free_urb_priv(uhci, urbp); 1521e9df41c5SAlan Stern usb_hcd_unlink_urb_from_ep(uhci_to_hcd(uhci), urb); 15220ed8fee1SAlan Stern 15230ed8fee1SAlan Stern spin_unlock(&uhci->lock); 15244a00027dSAlan Stern usb_hcd_giveback_urb(uhci_to_hcd(uhci), urb, status); 15250ed8fee1SAlan Stern spin_lock(&uhci->lock); 15260ed8fee1SAlan Stern 15270ed8fee1SAlan Stern /* If the queue is now empty, we can unlink the QH and give up its 15280ed8fee1SAlan Stern * reserved bandwidth. */ 15290ed8fee1SAlan Stern if (list_empty(&qh->queue)) { 15300ed8fee1SAlan Stern uhci_unlink_qh(uhci, qh); 15313ca2a321SAlan Stern if (qh->bandwidth_reserved) 15323ca2a321SAlan Stern uhci_release_bandwidth(uhci, qh); 15330ed8fee1SAlan Stern } 15340ed8fee1SAlan Stern } 15350ed8fee1SAlan Stern 15360ed8fee1SAlan Stern /* 15370ed8fee1SAlan Stern * Scan the URBs in a QH's queue 15380ed8fee1SAlan Stern */ 15390ed8fee1SAlan Stern #define QH_FINISHED_UNLINKING(qh) \ 15400ed8fee1SAlan Stern (qh->state == QH_STATE_UNLINKING && \ 15410ed8fee1SAlan Stern uhci->frame_number + uhci->is_stopped != qh->unlink_frame) 15420ed8fee1SAlan Stern 15437d12e780SDavid Howells static void uhci_scan_qh(struct uhci_hcd *uhci, struct uhci_qh *qh) 15440ed8fee1SAlan Stern { 15450ed8fee1SAlan Stern struct urb_priv *urbp; 15460ed8fee1SAlan Stern struct urb *urb; 15470ed8fee1SAlan Stern int status; 15480ed8fee1SAlan Stern 15490ed8fee1SAlan Stern while (!list_empty(&qh->queue)) { 15500ed8fee1SAlan Stern urbp = list_entry(qh->queue.next, struct urb_priv, node); 15510ed8fee1SAlan Stern urb = urbp->urb; 15520ed8fee1SAlan Stern 1553b1869000SAlan Stern if (qh->type == USB_ENDPOINT_XFER_ISOC) 15540ed8fee1SAlan Stern status = uhci_result_isochronous(uhci, urb); 1555b1869000SAlan Stern else 15560ed8fee1SAlan Stern status = uhci_result_common(uhci, urb); 15570ed8fee1SAlan Stern if (status == -EINPROGRESS) 15580ed8fee1SAlan Stern break; 15590ed8fee1SAlan Stern 15600ed8fee1SAlan Stern /* Dequeued but completed URBs can't be given back unless 15610ed8fee1SAlan Stern * the QH is stopped or has finished unlinking. */ 1562eb231054SAlan Stern if (urb->unlinked) { 15632775562aSAlan Stern if (QH_FINISHED_UNLINKING(qh)) 15642775562aSAlan Stern qh->is_stopped = 1; 15652775562aSAlan Stern else if (!qh->is_stopped) 15660ed8fee1SAlan Stern return; 15672775562aSAlan Stern } 15680ed8fee1SAlan Stern 15694a00027dSAlan Stern uhci_giveback_urb(uhci, qh, urb, status); 1570ee7d1f3fSAlan Stern if (status < 0) 15710ed8fee1SAlan Stern break; 15720ed8fee1SAlan Stern } 15730ed8fee1SAlan Stern 15740ed8fee1SAlan Stern /* If the QH is neither stopped nor finished unlinking (normal case), 15750ed8fee1SAlan Stern * our work here is done. */ 15762775562aSAlan Stern if (QH_FINISHED_UNLINKING(qh)) 15772775562aSAlan Stern qh->is_stopped = 1; 15782775562aSAlan Stern else if (!qh->is_stopped) 15790ed8fee1SAlan Stern return; 15800ed8fee1SAlan Stern 15810ed8fee1SAlan Stern /* Otherwise give back each of the dequeued URBs */ 15822775562aSAlan Stern restart: 15830ed8fee1SAlan Stern list_for_each_entry(urbp, &qh->queue, node) { 15840ed8fee1SAlan Stern urb = urbp->urb; 1585eb231054SAlan Stern if (urb->unlinked) { 158610b8e47dSAlan Stern 158710b8e47dSAlan Stern /* Fix up the TD links and save the toggles for 158810b8e47dSAlan Stern * non-Isochronous queues. For Isochronous queues, 158910b8e47dSAlan Stern * test for too-recent dequeues. */ 159010b8e47dSAlan Stern if (!uhci_cleanup_queue(uhci, qh, urb)) { 159110b8e47dSAlan Stern qh->is_stopped = 0; 159210b8e47dSAlan Stern return; 159310b8e47dSAlan Stern } 15944a00027dSAlan Stern uhci_giveback_urb(uhci, qh, urb, 0); 15950ed8fee1SAlan Stern goto restart; 15960ed8fee1SAlan Stern } 15970ed8fee1SAlan Stern } 15980ed8fee1SAlan Stern qh->is_stopped = 0; 15990ed8fee1SAlan Stern 16000ed8fee1SAlan Stern /* There are no more dequeued URBs. If there are still URBs on the 16010ed8fee1SAlan Stern * queue, the QH can now be re-activated. */ 16020ed8fee1SAlan Stern if (!list_empty(&qh->queue)) { 16030ed8fee1SAlan Stern if (qh->needs_fixup) 16040ed8fee1SAlan Stern uhci_fixup_toggles(qh, 0); 160584afddd7SAlan Stern 160684afddd7SAlan Stern /* If the first URB on the queue wants FSBR but its time 160784afddd7SAlan Stern * limit has expired, set the next TD to interrupt on 160884afddd7SAlan Stern * completion before reactivating the QH. */ 160984afddd7SAlan Stern urbp = list_entry(qh->queue.next, struct urb_priv, node); 161084afddd7SAlan Stern if (urbp->fsbr && qh->wait_expired) { 161184afddd7SAlan Stern struct uhci_td *td = list_entry(urbp->td_list.next, 161284afddd7SAlan Stern struct uhci_td, list); 161384afddd7SAlan Stern 161484afddd7SAlan Stern td->status |= __cpu_to_le32(TD_CTRL_IOC); 161584afddd7SAlan Stern } 161684afddd7SAlan Stern 16170ed8fee1SAlan Stern uhci_activate_qh(uhci, qh); 16180ed8fee1SAlan Stern } 16190ed8fee1SAlan Stern 16200ed8fee1SAlan Stern /* The queue is empty. The QH can become idle if it is fully 16210ed8fee1SAlan Stern * unlinked. */ 16220ed8fee1SAlan Stern else if (QH_FINISHED_UNLINKING(qh)) 16230ed8fee1SAlan Stern uhci_make_qh_idle(uhci, qh); 16241da177e4SLinus Torvalds } 16251da177e4SLinus Torvalds 16260ed8fee1SAlan Stern /* 162784afddd7SAlan Stern * Check for queues that have made some forward progress. 162884afddd7SAlan Stern * Returns 0 if the queue is not Isochronous, is ACTIVE, and 162984afddd7SAlan Stern * has not advanced since last examined; 1 otherwise. 1630b761d9d8SAlan Stern * 1631b761d9d8SAlan Stern * Early Intel controllers have a bug which causes qh->element sometimes 1632b761d9d8SAlan Stern * not to advance when a TD completes successfully. The queue remains 1633b761d9d8SAlan Stern * stuck on the inactive completed TD. We detect such cases and advance 1634b761d9d8SAlan Stern * the element pointer by hand. 163584afddd7SAlan Stern */ 163684afddd7SAlan Stern static int uhci_advance_check(struct uhci_hcd *uhci, struct uhci_qh *qh) 163784afddd7SAlan Stern { 163884afddd7SAlan Stern struct urb_priv *urbp = NULL; 163984afddd7SAlan Stern struct uhci_td *td; 164084afddd7SAlan Stern int ret = 1; 164184afddd7SAlan Stern unsigned status; 164284afddd7SAlan Stern 164384afddd7SAlan Stern if (qh->type == USB_ENDPOINT_XFER_ISOC) 1644c5e3b741SAlan Stern goto done; 164584afddd7SAlan Stern 164684afddd7SAlan Stern /* Treat an UNLINKING queue as though it hasn't advanced. 164784afddd7SAlan Stern * This is okay because reactivation will treat it as though 164884afddd7SAlan Stern * it has advanced, and if it is going to become IDLE then 164984afddd7SAlan Stern * this doesn't matter anyway. Furthermore it's possible 165084afddd7SAlan Stern * for an UNLINKING queue not to have any URBs at all, or 165184afddd7SAlan Stern * for its first URB not to have any TDs (if it was dequeued 165284afddd7SAlan Stern * just as it completed). So it's not easy in any case to 165384afddd7SAlan Stern * test whether such queues have advanced. */ 165484afddd7SAlan Stern if (qh->state != QH_STATE_ACTIVE) { 165584afddd7SAlan Stern urbp = NULL; 165684afddd7SAlan Stern status = 0; 165784afddd7SAlan Stern 165884afddd7SAlan Stern } else { 165984afddd7SAlan Stern urbp = list_entry(qh->queue.next, struct urb_priv, node); 166084afddd7SAlan Stern td = list_entry(urbp->td_list.next, struct uhci_td, list); 166184afddd7SAlan Stern status = td_status(td); 166284afddd7SAlan Stern if (!(status & TD_CTRL_ACTIVE)) { 166384afddd7SAlan Stern 166484afddd7SAlan Stern /* We're okay, the queue has advanced */ 166584afddd7SAlan Stern qh->wait_expired = 0; 166684afddd7SAlan Stern qh->advance_jiffies = jiffies; 1667c5e3b741SAlan Stern goto done; 166884afddd7SAlan Stern } 166984afddd7SAlan Stern ret = 0; 167084afddd7SAlan Stern } 167184afddd7SAlan Stern 167284afddd7SAlan Stern /* The queue hasn't advanced; check for timeout */ 1673c5e3b741SAlan Stern if (qh->wait_expired) 1674c5e3b741SAlan Stern goto done; 1675c5e3b741SAlan Stern 1676c5e3b741SAlan Stern if (time_after(jiffies, qh->advance_jiffies + QH_WAIT_TIMEOUT)) { 1677b761d9d8SAlan Stern 1678b761d9d8SAlan Stern /* Detect the Intel bug and work around it */ 167928b9325eSAlan Stern if (qh->post_td && qh_element(qh) == LINK_TO_TD(qh->post_td)) { 1680b761d9d8SAlan Stern qh->element = qh->post_td->link; 1681b761d9d8SAlan Stern qh->advance_jiffies = jiffies; 1682c5e3b741SAlan Stern ret = 1; 1683c5e3b741SAlan Stern goto done; 1684b761d9d8SAlan Stern } 1685b761d9d8SAlan Stern 168684afddd7SAlan Stern qh->wait_expired = 1; 168784afddd7SAlan Stern 168884afddd7SAlan Stern /* If the current URB wants FSBR, unlink it temporarily 168984afddd7SAlan Stern * so that we can safely set the next TD to interrupt on 169084afddd7SAlan Stern * completion. That way we'll know as soon as the queue 169184afddd7SAlan Stern * starts moving again. */ 169284afddd7SAlan Stern if (urbp && urbp->fsbr && !(status & TD_CTRL_IOC)) 169384afddd7SAlan Stern uhci_unlink_qh(uhci, qh); 1694c5e3b741SAlan Stern 1695c5e3b741SAlan Stern } else { 1696c5e3b741SAlan Stern /* Unmoving but not-yet-expired queues keep FSBR alive */ 1697c5e3b741SAlan Stern if (urbp) 1698c5e3b741SAlan Stern uhci_urbp_wants_fsbr(uhci, urbp); 169984afddd7SAlan Stern } 1700c5e3b741SAlan Stern 1701c5e3b741SAlan Stern done: 170284afddd7SAlan Stern return ret; 170384afddd7SAlan Stern } 170484afddd7SAlan Stern 170584afddd7SAlan Stern /* 17060ed8fee1SAlan Stern * Process events in the schedule, but only in one thread at a time 17070ed8fee1SAlan Stern */ 17087d12e780SDavid Howells static void uhci_scan_schedule(struct uhci_hcd *uhci) 17091da177e4SLinus Torvalds { 17100ed8fee1SAlan Stern int i; 17110ed8fee1SAlan Stern struct uhci_qh *qh; 17121da177e4SLinus Torvalds 17131da177e4SLinus Torvalds /* Don't allow re-entrant calls */ 17141da177e4SLinus Torvalds if (uhci->scan_in_progress) { 17151da177e4SLinus Torvalds uhci->need_rescan = 1; 17161da177e4SLinus Torvalds return; 17171da177e4SLinus Torvalds } 17181da177e4SLinus Torvalds uhci->scan_in_progress = 1; 17191da177e4SLinus Torvalds rescan: 17201da177e4SLinus Torvalds uhci->need_rescan = 0; 1721c5e3b741SAlan Stern uhci->fsbr_is_wanted = 0; 17221da177e4SLinus Torvalds 17236c1b445cSAlan Stern uhci_clear_next_interrupt(uhci); 17241da177e4SLinus Torvalds uhci_get_current_frame_number(uhci); 1725c8155cc5SAlan Stern uhci->cur_iso_frame = uhci->frame_number; 17261da177e4SLinus Torvalds 17270ed8fee1SAlan Stern /* Go through all the QH queues and process the URBs in each one */ 17280ed8fee1SAlan Stern for (i = 0; i < UHCI_NUM_SKELQH - 1; ++i) { 17290ed8fee1SAlan Stern uhci->next_qh = list_entry(uhci->skelqh[i]->node.next, 17300ed8fee1SAlan Stern struct uhci_qh, node); 17310ed8fee1SAlan Stern while ((qh = uhci->next_qh) != uhci->skelqh[i]) { 17320ed8fee1SAlan Stern uhci->next_qh = list_entry(qh->node.next, 17330ed8fee1SAlan Stern struct uhci_qh, node); 173484afddd7SAlan Stern 173584afddd7SAlan Stern if (uhci_advance_check(uhci, qh)) { 17367d12e780SDavid Howells uhci_scan_qh(uhci, qh); 1737c5e3b741SAlan Stern if (qh->state == QH_STATE_ACTIVE) { 1738c5e3b741SAlan Stern uhci_urbp_wants_fsbr(uhci, 1739c5e3b741SAlan Stern list_entry(qh->queue.next, struct urb_priv, node)); 1740c5e3b741SAlan Stern } 174184afddd7SAlan Stern } 17421da177e4SLinus Torvalds } 17430ed8fee1SAlan Stern } 17441da177e4SLinus Torvalds 1745c8155cc5SAlan Stern uhci->last_iso_frame = uhci->cur_iso_frame; 17461da177e4SLinus Torvalds if (uhci->need_rescan) 17471da177e4SLinus Torvalds goto rescan; 17481da177e4SLinus Torvalds uhci->scan_in_progress = 0; 17491da177e4SLinus Torvalds 1750c5e3b741SAlan Stern if (uhci->fsbr_is_on && !uhci->fsbr_is_wanted && 1751c5e3b741SAlan Stern !uhci->fsbr_expiring) { 1752c5e3b741SAlan Stern uhci->fsbr_expiring = 1; 1753c5e3b741SAlan Stern mod_timer(&uhci->fsbr_timer, jiffies + FSBR_OFF_DELAY); 1754c5e3b741SAlan Stern } 175584afddd7SAlan Stern 175604538a25SAlan Stern if (list_empty(&uhci->skel_unlink_qh->node)) 17571da177e4SLinus Torvalds uhci_clear_next_interrupt(uhci); 17581da177e4SLinus Torvalds else 17591da177e4SLinus Torvalds uhci_set_next_interrupt(uhci); 17601da177e4SLinus Torvalds } 1761