Lines Matching defs:uhci
28 static void uhci_set_next_interrupt(struct uhci_hcd *uhci)
30 if (uhci->is_stopped)
31 mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
32 uhci->term_td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
35 static inline void uhci_clear_next_interrupt(struct uhci_hcd *uhci)
37 uhci->term_td->status &= ~cpu_to_hc32(uhci, TD_CTRL_IOC);
46 static void uhci_fsbr_on(struct uhci_hcd *uhci)
53 uhci->fsbr_is_on = 1;
54 lqh = list_entry(uhci->skel_async_qh->node.prev,
56 lqh->link = LINK_TO_QH(uhci, uhci->skel_term_qh);
59 static void uhci_fsbr_off(struct uhci_hcd *uhci)
65 uhci->fsbr_is_on = 0;
66 lqh = list_entry(uhci->skel_async_qh->node.prev,
68 lqh->link = UHCI_PTR_TERM(uhci);
71 static void uhci_add_fsbr(struct uhci_hcd *uhci, struct urb *urb)
79 static void uhci_urbp_wants_fsbr(struct uhci_hcd *uhci, struct urb_priv *urbp)
82 uhci->fsbr_is_wanted = 1;
83 if (!uhci->fsbr_is_on)
84 uhci_fsbr_on(uhci);
85 else if (uhci->fsbr_expiring) {
86 uhci->fsbr_expiring = 0;
87 del_timer(&uhci->fsbr_timer);
94 struct uhci_hcd *uhci = (struct uhci_hcd *) _uhci;
97 spin_lock_irqsave(&uhci->lock, flags);
98 if (uhci->fsbr_expiring) {
99 uhci->fsbr_expiring = 0;
100 uhci_fsbr_off(uhci);
102 spin_unlock_irqrestore(&uhci->lock, flags);
106 static struct uhci_td *uhci_alloc_td(struct uhci_hcd *uhci)
111 td = dma_pool_alloc(uhci->td_pool, GFP_ATOMIC, &dma_handle);
124 static void uhci_free_td(struct uhci_hcd *uhci, struct uhci_td *td)
127 dev_WARN(uhci_dev(uhci), "td %p still in list!\n", td);
129 dev_WARN(uhci_dev(uhci), "td %p still in fl_list!\n", td);
131 dma_pool_free(uhci->td_pool, td, td->dma_handle);
134 static inline void uhci_fill_td(struct uhci_hcd *uhci, struct uhci_td *td,
137 td->status = cpu_to_hc32(uhci, status);
138 td->token = cpu_to_hc32(uhci, token);
139 td->buffer = cpu_to_hc32(uhci, buffer);
155 static inline void uhci_insert_td_in_frame_list(struct uhci_hcd *uhci,
163 if (uhci->frame_cpu[framenum]) {
166 ftd = uhci->frame_cpu[framenum];
173 ltd->link = LINK_TO_TD(uhci, td);
175 td->link = uhci->frame[framenum];
177 uhci->frame[framenum] = LINK_TO_TD(uhci, td);
178 uhci->frame_cpu[framenum] = td;
182 static inline void uhci_remove_td_from_frame_list(struct uhci_hcd *uhci,
191 if (uhci->frame_cpu[td->frame] == td) {
193 uhci->frame[td->frame] = td->link;
194 uhci->frame_cpu[td->frame] = NULL;
201 uhci->frame[td->frame] = LINK_TO_TD(uhci, ntd);
202 uhci->frame_cpu[td->frame] = ntd;
215 static inline void uhci_remove_tds_from_frame(struct uhci_hcd *uhci,
222 ftd = uhci->frame_cpu[framenum];
225 uhci->frame[framenum] = ltd->link;
226 uhci->frame_cpu[framenum] = NULL;
236 static void uhci_unlink_isochronous_tds(struct uhci_hcd *uhci, struct urb *urb)
242 uhci_remove_td_from_frame_list(uhci, td);
245 static struct uhci_qh *uhci_alloc_qh(struct uhci_hcd *uhci,
251 qh = dma_pool_alloc(uhci->qh_pool, GFP_ATOMIC, &dma_handle);
258 qh->element = UHCI_PTR_TERM(uhci);
259 qh->link = UHCI_PTR_TERM(uhci);
267 qh->dummy_td = uhci_alloc_td(uhci);
269 dma_pool_free(uhci->qh_pool, qh, dma_handle);
293 static void uhci_free_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
297 dev_WARN(uhci_dev(uhci), "qh %p list not empty!\n", qh);
303 uhci_free_td(uhci, qh->dummy_td);
305 dma_pool_free(uhci->qh_pool, qh, qh->dma_handle);
315 static int uhci_cleanup_queue(struct uhci_hcd *uhci, struct uhci_qh *qh,
327 ret = (uhci->frame_number + uhci->is_stopped !=
351 if (qh_element(qh) == UHCI_PTR_TERM(uhci))
353 qh->element = UHCI_PTR_TERM(uhci);
363 qh->initial_toggle = uhci_toggle(td_token(uhci, td));
373 static void uhci_fixup_toggles(struct uhci_hcd *uhci, struct uhci_qh *qh,
388 else if (qh_element(qh) != UHCI_PTR_TERM(uhci))
400 if (toggle > 1 || uhci_toggle(td_token(uhci, td)) == toggle) {
403 toggle = uhci_toggle(td_token(uhci, td)) ^ 1;
408 td->token ^= cpu_to_hc32(uhci,
425 static inline void link_iso(struct uhci_hcd *uhci, struct uhci_qh *qh)
427 list_add_tail(&qh->node, &uhci->skel_iso_qh->node);
436 static void link_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh)
440 list_add_tail(&qh->node, &uhci->skelqh[qh->skel]->node);
445 pqh->link = LINK_TO_QH(uhci, qh);
452 static void link_async(struct uhci_hcd *uhci, struct uhci_qh *qh)
460 list_for_each_entry_reverse(pqh, &uhci->skel_async_qh->node, node) {
469 link_to_new_qh = LINK_TO_QH(uhci, qh);
475 uhci->skel_term_qh->link = link_to_new_qh;
481 static void uhci_activate_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
487 if (qh_element(qh) == UHCI_PTR_TERM(uhci)) {
493 qh->element = LINK_TO_TD(uhci, td);
506 if (qh == uhci->next_qh)
507 uhci->next_qh = list_entry(qh->node.next, struct uhci_qh,
512 link_iso(uhci, qh);
514 link_interrupt(uhci, qh);
516 link_async(uhci, qh);
522 static void unlink_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh)
534 static void unlink_async(struct uhci_hcd *uhci, struct uhci_qh *qh)
545 uhci->skel_term_qh->link = link_to_next_qh;
552 static void uhci_unlink_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
563 unlink_interrupt(uhci, qh);
565 unlink_async(uhci, qh);
567 uhci_get_current_frame_number(uhci);
568 qh->unlink_frame = uhci->frame_number;
571 if (list_empty(&uhci->skel_unlink_qh->node) || uhci->is_stopped)
572 uhci_set_next_interrupt(uhci);
575 if (qh == uhci->next_qh)
576 uhci->next_qh = list_entry(qh->node.next, struct uhci_qh,
578 list_move_tail(&qh->node, &uhci->skel_unlink_qh->node);
587 static void uhci_make_qh_idle(struct uhci_hcd *uhci, struct uhci_qh *qh)
591 if (qh == uhci->next_qh)
592 uhci->next_qh = list_entry(qh->node.next, struct uhci_qh,
594 list_move(&qh->node, &uhci->idle_qh_list);
599 uhci_free_td(uhci, qh->post_td);
604 if (uhci->num_waiting)
605 wake_up_all(&uhci->waitqh);
611 static int uhci_highest_load(struct uhci_hcd *uhci, int phase, int period)
613 int highest_load = uhci->load[phase];
616 highest_load = max_t(int, highest_load, uhci->load[phase]);
624 static int uhci_check_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh)
631 minimax_load = uhci_highest_load(uhci, qh->phase, qh->period);
637 minimax_load = uhci_highest_load(uhci, qh->phase, qh->period);
639 load = uhci_highest_load(uhci, phase, qh->period);
649 dev_dbg(uhci_dev(uhci), "bandwidth allocation failed: "
660 static void uhci_reserve_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh)
667 uhci->load[i] += load;
668 uhci->total_load += load;
670 uhci_to_hcd(uhci)->self.bandwidth_allocated =
671 uhci->total_load / MAX_PHASE;
674 ++uhci_to_hcd(uhci)->self.bandwidth_int_reqs;
678 ++uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs;
683 dev_dbg(uhci_dev(uhci),
693 static void uhci_release_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh)
700 uhci->load[i] -= load;
701 uhci->total_load -= load;
703 uhci_to_hcd(uhci)->self.bandwidth_allocated =
704 uhci->total_load / MAX_PHASE;
707 --uhci_to_hcd(uhci)->self.bandwidth_int_reqs;
711 --uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs;
716 dev_dbg(uhci_dev(uhci),
723 static inline struct urb_priv *uhci_alloc_urb_priv(struct uhci_hcd *uhci,
741 static void uhci_free_urb_priv(struct uhci_hcd *uhci,
747 dev_WARN(uhci_dev(uhci), "urb %p still on QH's list!\n",
752 uhci_free_td(uhci, td);
761 * <status> is (td_status(uhci, td) & 0xF60000), a.k.a.
762 * uhci_status_bits(td_status(uhci, td)).
790 static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
815 uhci_fill_td(uhci, td, status, destination | uhci_explen(8),
845 td = uhci_alloc_td(uhci);
848 *plink = LINK_TO_TD(uhci, td);
854 uhci_fill_td(uhci, td, status,
865 td = uhci_alloc_td(uhci);
868 *plink = LINK_TO_TD(uhci, td);
875 uhci_fill_td(uhci, td, status | TD_CTRL_IOC,
882 td = uhci_alloc_td(uhci);
885 *plink = LINK_TO_TD(uhci, td);
887 uhci_fill_td(uhci, td, 0, USB_PID_OUT | uhci_explen(0), 0);
889 qh->dummy_td->status |= cpu_to_hc32(uhci, TD_CTRL_ACTIVE);
901 uhci_add_fsbr(uhci, urb);
916 static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
975 td = uhci_alloc_td(uhci);
978 *plink = LINK_TO_TD(uhci, td);
981 uhci_fill_td(uhci, td, status,
1011 td = uhci_alloc_td(uhci);
1014 *plink = LINK_TO_TD(uhci, td);
1017 uhci_fill_td(uhci, td, status,
1032 td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
1037 td = uhci_alloc_td(uhci);
1040 *plink = LINK_TO_TD(uhci, td);
1042 uhci_fill_td(uhci, td, 0, USB_PID_OUT | uhci_explen(0), 0);
1044 qh->dummy_td->status |= cpu_to_hc32(uhci, TD_CTRL_ACTIVE);
1057 static int uhci_submit_bulk(struct uhci_hcd *uhci, struct urb *urb,
1068 ret = uhci_submit_common(uhci, urb, qh);
1070 uhci_add_fsbr(uhci, urb);
1074 static int uhci_submit_interrupt(struct uhci_hcd *uhci, struct urb *urb,
1104 ret = uhci_check_bandwidth(uhci, qh);
1111 ret = uhci_submit_common(uhci, urb, qh);
1115 uhci_reserve_bandwidth(uhci, qh);
1123 static int uhci_fixup_short_transfer(struct uhci_hcd *uhci,
1137 qh->element = LINK_TO_TD(uhci, td);
1147 uhci_toggle(td_token(uhci, qh->post_td)) ^ 1;
1148 uhci_fixup_toggles(uhci, qh, 1);
1163 uhci_free_td(uhci, td);
1171 static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb)
1183 ctrlstat = td_status(uhci, td);
1193 uhci_packetout(td_token(uhci, td)));
1202 uhci_show_qh(uhci, urbp->qh, errbuf,
1209 } else if (len < uhci_expected_length(td_token(uhci, td))) {
1229 uhci_free_td(uhci, qh->post_td);
1241 qh->element = UHCI_PTR_TERM(uhci);
1244 qh->initial_toggle = uhci_toggle(td_token(uhci, td)) ^
1248 ret = uhci_fixup_short_transfer(uhci, qh, urbp);
1255 static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb,
1269 uhci_get_current_frame_number(uhci);
1275 i = uhci_check_bandwidth(uhci, qh);
1280 next = uhci->frame_number + 10;
1290 next = uhci->frame_number + 1;
1320 dev_dbg(uhci_dev(uhci), "iso underrun %p (%u+%u < %u)\n",
1329 if (uhci_frame_before_eq(uhci->last_iso_frame + UHCI_NUMFRAMES,
1338 td = uhci_alloc_td(uhci);
1343 uhci_fill_td(uhci, td, status, destination |
1350 td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
1355 uhci_insert_td_in_frame_list(uhci, td, frame);
1366 uhci_reserve_bandwidth(uhci, qh);
1370 static int uhci_result_isochronous(struct uhci_hcd *uhci, struct urb *urb)
1381 if (uhci_frame_before_eq(uhci->cur_iso_frame, qh->iso_frame))
1384 uhci_remove_tds_from_frame(uhci, qh->iso_frame);
1386 ctrlstat = td_status(uhci, td);
1402 uhci_free_td(uhci, td);
1413 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
1418 spin_lock_irqsave(&uhci->lock, flags);
1425 urbp = uhci_alloc_urb_priv(uhci, urb);
1432 qh = uhci_alloc_qh(uhci, urb->dev, urb->ep);
1440 ret = uhci_submit_control(uhci, urb, qh);
1443 ret = uhci_submit_bulk(uhci, urb, qh);
1446 ret = uhci_submit_interrupt(uhci, urb, qh);
1450 ret = uhci_submit_isochronous(uhci, urb, qh);
1464 uhci_activate_qh(uhci, qh);
1465 uhci_urbp_wants_fsbr(uhci, urbp);
1471 uhci_make_qh_idle(uhci, qh); /* Reclaim unused QH */
1473 uhci_free_urb_priv(uhci, urbp);
1478 spin_unlock_irqrestore(&uhci->lock, flags);
1484 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
1489 spin_lock_irqsave(&uhci->lock, flags);
1498 uhci_unlink_isochronous_tds(uhci, urb);
1502 uhci_get_current_frame_number(uhci);
1503 if (uhci_frame_before_eq(urb->start_frame, uhci->frame_number))
1504 qh->unlink_frame = uhci->frame_number;
1507 uhci_unlink_qh(uhci, qh);
1510 spin_unlock_irqrestore(&uhci->lock, flags);
1517 static void uhci_giveback_urb(struct uhci_hcd *uhci, struct uhci_qh *qh,
1519 __releases(uhci->lock)
1520 __acquires(uhci->lock)
1553 uhci_free_urb_priv(uhci, urbp);
1554 usb_hcd_unlink_urb_from_ep(uhci_to_hcd(uhci), urb);
1556 spin_unlock(&uhci->lock);
1557 usb_hcd_giveback_urb(uhci_to_hcd(uhci), urb, status);
1558 spin_lock(&uhci->lock);
1563 uhci_unlink_qh(uhci, qh);
1565 uhci_release_bandwidth(uhci, qh);
1574 uhci->frame_number + uhci->is_stopped != qh->unlink_frame)
1576 static void uhci_scan_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
1587 status = uhci_result_isochronous(uhci, urb);
1589 status = uhci_result_common(uhci, urb);
1602 uhci_giveback_urb(uhci, qh, urb, status);
1623 if (!uhci_cleanup_queue(uhci, qh, urb)) {
1627 uhci_giveback_urb(uhci, qh, urb, 0);
1637 uhci_fixup_toggles(uhci, qh, 0);
1647 td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
1650 uhci_activate_qh(uhci, qh);
1656 uhci_make_qh_idle(uhci, qh);
1669 static int uhci_advance_check(struct uhci_hcd *uhci, struct uhci_qh *qh)
1694 status = td_status(uhci, td);
1702 ret = uhci->is_stopped;
1713 LINK_TO_TD(uhci, qh->post_td)) {
1727 uhci_unlink_qh(uhci, qh);
1732 uhci_urbp_wants_fsbr(uhci, urbp);
1742 static void uhci_scan_schedule(struct uhci_hcd *uhci)
1748 if (uhci->scan_in_progress) {
1749 uhci->need_rescan = 1;
1752 uhci->scan_in_progress = 1;
1754 uhci->need_rescan = 0;
1755 uhci->fsbr_is_wanted = 0;
1757 uhci_clear_next_interrupt(uhci);
1758 uhci_get_current_frame_number(uhci);
1759 uhci->cur_iso_frame = uhci->frame_number;
1763 uhci->next_qh = list_entry(uhci->skelqh[i]->node.next,
1765 while ((qh = uhci->next_qh) != uhci->skelqh[i]) {
1766 uhci->next_qh = list_entry(qh->node.next,
1769 if (uhci_advance_check(uhci, qh)) {
1770 uhci_scan_qh(uhci, qh);
1772 uhci_urbp_wants_fsbr(uhci,
1779 uhci->last_iso_frame = uhci->cur_iso_frame;
1780 if (uhci->need_rescan)
1782 uhci->scan_in_progress = 0;
1784 if (uhci->fsbr_is_on && !uhci->fsbr_is_wanted &&
1785 !uhci->fsbr_expiring) {
1786 uhci->fsbr_expiring = 1;
1787 mod_timer(&uhci->fsbr_timer, jiffies + FSBR_OFF_DELAY);
1790 if (list_empty(&uhci->skel_unlink_qh->node))
1791 uhci_clear_next_interrupt(uhci);
1793 uhci_set_next_interrupt(uhci);