Lines Matching defs:uhci
29 static void uhci_set_next_interrupt(struct uhci_hcd *uhci)
31 if (uhci->is_stopped)
32 mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
33 uhci->term_td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
36 static inline void uhci_clear_next_interrupt(struct uhci_hcd *uhci)
38 uhci->term_td->status &= ~cpu_to_hc32(uhci, TD_CTRL_IOC);
47 static void uhci_fsbr_on(struct uhci_hcd *uhci)
54 uhci->fsbr_is_on = 1;
55 lqh = list_entry(uhci->skel_async_qh->node.prev,
57 lqh->link = LINK_TO_QH(uhci, uhci->skel_term_qh);
60 static void uhci_fsbr_off(struct uhci_hcd *uhci)
66 uhci->fsbr_is_on = 0;
67 lqh = list_entry(uhci->skel_async_qh->node.prev,
69 lqh->link = UHCI_PTR_TERM(uhci);
72 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 = from_timer(uhci, t, fsbr_timer);
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_zalloc(uhci->qh_pool, GFP_ATOMIC, &dma_handle);
257 qh->element = UHCI_PTR_TERM(uhci);
258 qh->link = UHCI_PTR_TERM(uhci);
266 qh->dummy_td = uhci_alloc_td(uhci);
268 dma_pool_free(uhci->qh_pool, qh, dma_handle);
292 static void uhci_free_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
296 dev_WARN(uhci_dev(uhci), "qh %p list not empty!\n", qh);
302 uhci_free_td(uhci, qh->dummy_td);
304 dma_pool_free(uhci->qh_pool, qh, qh->dma_handle);
314 static int uhci_cleanup_queue(struct uhci_hcd *uhci, struct uhci_qh *qh,
326 ret = (uhci->frame_number + uhci->is_stopped !=
350 if (qh_element(qh) == UHCI_PTR_TERM(uhci))
352 qh->element = UHCI_PTR_TERM(uhci);
362 qh->initial_toggle = uhci_toggle(td_token(uhci, td));
372 static void uhci_fixup_toggles(struct uhci_hcd *uhci, struct uhci_qh *qh,
387 else if (qh_element(qh) != UHCI_PTR_TERM(uhci))
399 if (toggle > 1 || uhci_toggle(td_token(uhci, td)) == toggle) {
402 toggle = uhci_toggle(td_token(uhci, td)) ^ 1;
407 td->token ^= cpu_to_hc32(uhci,
424 static inline void link_iso(struct uhci_hcd *uhci, struct uhci_qh *qh)
426 list_add_tail(&qh->node, &uhci->skel_iso_qh->node);
435 static void link_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh)
439 list_add_tail(&qh->node, &uhci->skelqh[qh->skel]->node);
444 pqh->link = LINK_TO_QH(uhci, qh);
451 static void link_async(struct uhci_hcd *uhci, struct uhci_qh *qh)
459 list_for_each_entry_reverse(pqh, &uhci->skel_async_qh->node, node) {
468 link_to_new_qh = LINK_TO_QH(uhci, qh);
474 uhci->skel_term_qh->link = link_to_new_qh;
480 static void uhci_activate_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
486 if (qh_element(qh) == UHCI_PTR_TERM(uhci)) {
492 qh->element = LINK_TO_TD(uhci, td);
505 if (qh == uhci->next_qh)
506 uhci->next_qh = list_entry(qh->node.next, struct uhci_qh,
511 link_iso(uhci, qh);
513 link_interrupt(uhci, qh);
515 link_async(uhci, qh);
521 static void unlink_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh)
533 static void unlink_async(struct uhci_hcd *uhci, struct uhci_qh *qh)
544 uhci->skel_term_qh->link = link_to_next_qh;
551 static void uhci_unlink_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
562 unlink_interrupt(uhci, qh);
564 unlink_async(uhci, qh);
566 uhci_get_current_frame_number(uhci);
567 qh->unlink_frame = uhci->frame_number;
570 if (list_empty(&uhci->skel_unlink_qh->node) || uhci->is_stopped)
571 uhci_set_next_interrupt(uhci);
574 if (qh == uhci->next_qh)
575 uhci->next_qh = list_entry(qh->node.next, struct uhci_qh,
577 list_move_tail(&qh->node, &uhci->skel_unlink_qh->node);
586 static void uhci_make_qh_idle(struct uhci_hcd *uhci, struct uhci_qh *qh)
590 if (qh == uhci->next_qh)
591 uhci->next_qh = list_entry(qh->node.next, struct uhci_qh,
593 list_move(&qh->node, &uhci->idle_qh_list);
598 uhci_free_td(uhci, qh->post_td);
603 if (uhci->num_waiting)
604 wake_up_all(&uhci->waitqh);
610 static int uhci_highest_load(struct uhci_hcd *uhci, int phase, int period)
612 int highest_load = uhci->load[phase];
615 highest_load = max_t(int, highest_load, uhci->load[phase]);
623 static int uhci_check_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh)
630 minimax_load = uhci_highest_load(uhci, qh->phase, qh->period);
636 minimax_load = uhci_highest_load(uhci, qh->phase, qh->period);
638 load = uhci_highest_load(uhci, phase, qh->period);
648 dev_dbg(uhci_dev(uhci), "bandwidth allocation failed: "
659 static void uhci_reserve_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh)
666 uhci->load[i] += load;
667 uhci->total_load += load;
669 uhci_to_hcd(uhci)->self.bandwidth_allocated =
670 uhci->total_load / MAX_PHASE;
673 ++uhci_to_hcd(uhci)->self.bandwidth_int_reqs;
677 ++uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs;
682 dev_dbg(uhci_dev(uhci),
692 static void uhci_release_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh)
699 uhci->load[i] -= load;
700 uhci->total_load -= load;
702 uhci_to_hcd(uhci)->self.bandwidth_allocated =
703 uhci->total_load / MAX_PHASE;
706 --uhci_to_hcd(uhci)->self.bandwidth_int_reqs;
710 --uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs;
715 dev_dbg(uhci_dev(uhci),
722 static inline struct urb_priv *uhci_alloc_urb_priv(struct uhci_hcd *uhci,
740 static void uhci_free_urb_priv(struct uhci_hcd *uhci,
746 dev_WARN(uhci_dev(uhci), "urb %p still on QH's list!\n",
751 uhci_free_td(uhci, td);
760 * <status> is (td_status(uhci, td) & 0xF60000), a.k.a.
761 * uhci_status_bits(td_status(uhci, td)).
789 static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
814 uhci_fill_td(uhci, td, status, destination | uhci_explen(8),
844 td = uhci_alloc_td(uhci);
847 *plink = LINK_TO_TD(uhci, td);
853 uhci_fill_td(uhci, td, status,
864 td = uhci_alloc_td(uhci);
867 *plink = LINK_TO_TD(uhci, td);
874 uhci_fill_td(uhci, td, status | TD_CTRL_IOC,
881 td = uhci_alloc_td(uhci);
884 *plink = LINK_TO_TD(uhci, td);
886 uhci_fill_td(uhci, td, 0, USB_PID_OUT | uhci_explen(0), 0);
888 qh->dummy_td->status |= cpu_to_hc32(uhci, TD_CTRL_ACTIVE);
900 uhci_add_fsbr(uhci, urb);
915 static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb,
974 td = uhci_alloc_td(uhci);
977 *plink = LINK_TO_TD(uhci, td);
980 uhci_fill_td(uhci, td, status,
1010 td = uhci_alloc_td(uhci);
1013 *plink = LINK_TO_TD(uhci, td);
1016 uhci_fill_td(uhci, td, status,
1031 td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
1036 td = uhci_alloc_td(uhci);
1039 *plink = LINK_TO_TD(uhci, td);
1041 uhci_fill_td(uhci, td, 0, USB_PID_OUT | uhci_explen(0), 0);
1043 qh->dummy_td->status |= cpu_to_hc32(uhci, TD_CTRL_ACTIVE);
1056 static int uhci_submit_bulk(struct uhci_hcd *uhci, struct urb *urb,
1067 ret = uhci_submit_common(uhci, urb, qh);
1069 uhci_add_fsbr(uhci, urb);
1073 static int uhci_submit_interrupt(struct uhci_hcd *uhci, struct urb *urb,
1103 ret = uhci_check_bandwidth(uhci, qh);
1110 ret = uhci_submit_common(uhci, urb, qh);
1114 uhci_reserve_bandwidth(uhci, qh);
1122 static int uhci_fixup_short_transfer(struct uhci_hcd *uhci,
1136 qh->element = LINK_TO_TD(uhci, td);
1146 uhci_toggle(td_token(uhci, qh->post_td)) ^ 1;
1147 uhci_fixup_toggles(uhci, qh, 1);
1162 uhci_free_td(uhci, td);
1170 static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb)
1182 ctrlstat = td_status(uhci, td);
1192 uhci_packetout(td_token(uhci, td)));
1201 uhci_show_qh(uhci, urbp->qh, errbuf,
1208 } else if (len < uhci_expected_length(td_token(uhci, td))) {
1228 uhci_free_td(uhci, qh->post_td);
1240 qh->element = UHCI_PTR_TERM(uhci);
1243 qh->initial_toggle = uhci_toggle(td_token(uhci, td)) ^
1247 ret = uhci_fixup_short_transfer(uhci, qh, urbp);
1254 static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb,
1268 uhci_get_current_frame_number(uhci);
1274 i = uhci_check_bandwidth(uhci, qh);
1279 next = uhci->frame_number + 10;
1289 next = uhci->frame_number + 1;
1319 dev_dbg(uhci_dev(uhci), "iso underrun %p (%u+%u < %u)\n",
1328 if (uhci_frame_before_eq(uhci->last_iso_frame + UHCI_NUMFRAMES,
1337 td = uhci_alloc_td(uhci);
1342 uhci_fill_td(uhci, td, status, destination |
1349 td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
1354 uhci_insert_td_in_frame_list(uhci, td, frame);
1365 uhci_reserve_bandwidth(uhci, qh);
1369 static int uhci_result_isochronous(struct uhci_hcd *uhci, struct urb *urb)
1380 if (uhci_frame_before_eq(uhci->cur_iso_frame, qh->iso_frame))
1383 uhci_remove_tds_from_frame(uhci, qh->iso_frame);
1385 ctrlstat = td_status(uhci, td);
1401 uhci_free_td(uhci, td);
1412 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
1417 spin_lock_irqsave(&uhci->lock, flags);
1424 urbp = uhci_alloc_urb_priv(uhci, urb);
1431 qh = uhci_alloc_qh(uhci, urb->dev, urb->ep);
1439 ret = uhci_submit_control(uhci, urb, qh);
1442 ret = uhci_submit_bulk(uhci, urb, qh);
1445 ret = uhci_submit_interrupt(uhci, urb, qh);
1449 ret = uhci_submit_isochronous(uhci, urb, qh);
1463 uhci_activate_qh(uhci, qh);
1464 uhci_urbp_wants_fsbr(uhci, urbp);
1470 uhci_make_qh_idle(uhci, qh); /* Reclaim unused QH */
1472 uhci_free_urb_priv(uhci, urbp);
1477 spin_unlock_irqrestore(&uhci->lock, flags);
1483 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
1488 spin_lock_irqsave(&uhci->lock, flags);
1497 uhci_unlink_isochronous_tds(uhci, urb);
1501 uhci_get_current_frame_number(uhci);
1502 if (uhci_frame_before_eq(urb->start_frame, uhci->frame_number))
1503 qh->unlink_frame = uhci->frame_number;
1506 uhci_unlink_qh(uhci, qh);
1509 spin_unlock_irqrestore(&uhci->lock, flags);
1516 static void uhci_giveback_urb(struct uhci_hcd *uhci, struct uhci_qh *qh,
1518 __releases(uhci->lock)
1519 __acquires(uhci->lock)
1552 uhci_free_urb_priv(uhci, urbp);
1553 usb_hcd_unlink_urb_from_ep(uhci_to_hcd(uhci), urb);
1555 spin_unlock(&uhci->lock);
1556 usb_hcd_giveback_urb(uhci_to_hcd(uhci), urb, status);
1557 spin_lock(&uhci->lock);
1562 uhci_unlink_qh(uhci, qh);
1564 uhci_release_bandwidth(uhci, qh);
1573 uhci->frame_number + uhci->is_stopped != qh->unlink_frame)
1575 static void uhci_scan_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
1586 status = uhci_result_isochronous(uhci, urb);
1588 status = uhci_result_common(uhci, urb);
1601 uhci_giveback_urb(uhci, qh, urb, status);
1622 if (!uhci_cleanup_queue(uhci, qh, urb)) {
1626 uhci_giveback_urb(uhci, qh, urb, 0);
1636 uhci_fixup_toggles(uhci, qh, 0);
1646 td->status |= cpu_to_hc32(uhci, TD_CTRL_IOC);
1649 uhci_activate_qh(uhci, qh);
1655 uhci_make_qh_idle(uhci, qh);
1668 static int uhci_advance_check(struct uhci_hcd *uhci, struct uhci_qh *qh)
1693 status = td_status(uhci, td);
1701 ret = uhci->is_stopped;
1712 LINK_TO_TD(uhci, qh->post_td)) {
1726 uhci_unlink_qh(uhci, qh);
1731 uhci_urbp_wants_fsbr(uhci, urbp);
1741 static void uhci_scan_schedule(struct uhci_hcd *uhci)
1747 if (uhci->scan_in_progress) {
1748 uhci->need_rescan = 1;
1751 uhci->scan_in_progress = 1;
1753 uhci->need_rescan = 0;
1754 uhci->fsbr_is_wanted = 0;
1756 uhci_clear_next_interrupt(uhci);
1757 uhci_get_current_frame_number(uhci);
1758 uhci->cur_iso_frame = uhci->frame_number;
1762 uhci->next_qh = list_entry(uhci->skelqh[i]->node.next,
1764 while ((qh = uhci->next_qh) != uhci->skelqh[i]) {
1765 uhci->next_qh = list_entry(qh->node.next,
1768 if (uhci_advance_check(uhci, qh)) {
1769 uhci_scan_qh(uhci, qh);
1771 uhci_urbp_wants_fsbr(uhci,
1778 uhci->last_iso_frame = uhci->cur_iso_frame;
1779 if (uhci->need_rescan)
1781 uhci->scan_in_progress = 0;
1783 if (uhci->fsbr_is_on && !uhci->fsbr_is_wanted &&
1784 !uhci->fsbr_expiring) {
1785 uhci->fsbr_expiring = 1;
1786 mod_timer(&uhci->fsbr_timer, jiffies + FSBR_OFF_DELAY);
1789 if (list_empty(&uhci->skel_unlink_qh->node))
1790 uhci_clear_next_interrupt(uhci);
1792 uhci_set_next_interrupt(uhci);