// SPDX-License-Identifier: GPL-2.0 /* * Universal Host Controller Interface driver for USB. * * Maintainer: Alan Stern <[email protected]> * * (C) Copyright 1999 Linus Torvalds * (C) Copyright 1999-2002 Johannes Erdfelt, [email protected] * (C) Copyright 1999 Randy Dunlap * (C) Copyright 1999 Georg Acher, [email protected] * (C) Copyright 1999 Deti Fliegl, [email protected] * (C) Copyright 1999 Thomas Sailer, [email protected] * (C) Copyright 1999 Roman Weissgaerber, [email protected] * (C) Copyright 2000 Yggdrasil Computing, Inc. (port of new PCI interface * support from usb-ohci.c by Adam Richter, [email protected]). * (C) Copyright 1999 Gregory P. Smith (from usb-ohci.c) * (C) Copyright 2004-2007 Alan Stern, [email protected] */ /* * Technically, updating td->status here is a race, but it's not really a * problem. The worst that can happen is that we set the IOC bit again * generating a spurious interrupt. We could fix this by creating another * QH and leaving the IOC bit always set, but then we would have to play * games with the FSBR code to make sure we get the correct order in all * the cases. I don't think it's worth the effort */ static void uhci_set_next_interrupt(struct uhci_hcd *uhci) { … } static inline void uhci_clear_next_interrupt(struct uhci_hcd *uhci) { … } /* * Full-Speed Bandwidth Reclamation (FSBR). * We turn on FSBR whenever a queue that wants it is advancing, * and leave it on for a short time thereafter. */ static void uhci_fsbr_on(struct uhci_hcd *uhci) { … } static void uhci_fsbr_off(struct uhci_hcd *uhci) { … } static void uhci_add_fsbr(struct uhci_hcd *uhci, struct urb *urb) { … } static void uhci_urbp_wants_fsbr(struct uhci_hcd *uhci, struct urb_priv *urbp) { … } static void uhci_fsbr_timeout(struct timer_list *t) { … } static struct uhci_td *uhci_alloc_td(struct uhci_hcd *uhci) { … } static void uhci_free_td(struct uhci_hcd *uhci, struct uhci_td *td) { … } static inline void uhci_fill_td(struct uhci_hcd *uhci, struct uhci_td *td, u32 status, u32 token, u32 buffer) { … } static void uhci_add_td_to_urbp(struct uhci_td *td, struct urb_priv *urbp) { … } static void uhci_remove_td_from_urbp(struct uhci_td *td) { … } /* * We insert Isochronous URBs directly into the frame list at the beginning */ static inline void uhci_insert_td_in_frame_list(struct uhci_hcd *uhci, struct uhci_td *td, unsigned framenum) { … } static inline void uhci_remove_td_from_frame_list(struct uhci_hcd *uhci, struct uhci_td *td) { … } static inline void uhci_remove_tds_from_frame(struct uhci_hcd *uhci, unsigned int framenum) { … } /* * Remove all the TDs for an Isochronous URB from the frame list */ static void uhci_unlink_isochronous_tds(struct uhci_hcd *uhci, struct urb *urb) { … } static struct uhci_qh *uhci_alloc_qh(struct uhci_hcd *uhci, struct usb_device *udev, struct usb_host_endpoint *hep) { … } static void uhci_free_qh(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } /* * When a queue is stopped and a dequeued URB is given back, adjust * the previous TD link (if the URB isn't first on the queue) or * save its toggle value (if it is first and is currently executing). * * Returns 0 if the URB should not yet be given back, 1 otherwise. */ static int uhci_cleanup_queue(struct uhci_hcd *uhci, struct uhci_qh *qh, struct urb *urb) { … } /* * Fix up the data toggles for URBs in a queue, when one of them * terminates early (short transfer, error, or dequeued). */ static void uhci_fixup_toggles(struct uhci_hcd *uhci, struct uhci_qh *qh, int skip_first) { … } /* * Link an Isochronous QH into its skeleton's list */ static inline void link_iso(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } /* * Link a high-period interrupt QH into the schedule at the end of its * skeleton's list */ static void link_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } /* * Link a period-1 interrupt or async QH into the schedule at the * correct spot in the async skeleton's list, and update the FSBR link */ static void link_async(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } /* * Put a QH on the schedule in both hardware and software */ static void uhci_activate_qh(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } /* * Unlink a high-period interrupt QH from the schedule */ static void unlink_interrupt(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } /* * Unlink a period-1 interrupt or async QH from the schedule */ static void unlink_async(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } /* * Take a QH off the hardware schedule */ static void uhci_unlink_qh(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } /* * When we and the controller are through with a QH, it becomes IDLE. * This happens when a QH has been off the schedule (on the unlinking * list) for more than one frame, or when an error occurs while adding * the first URB onto a new QH. */ static void uhci_make_qh_idle(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } /* * Find the highest existing bandwidth load for a given phase and period. */ static int uhci_highest_load(struct uhci_hcd *uhci, int phase, int period) { … } /* * Set qh->phase to the optimal phase for a periodic transfer and * check whether the bandwidth requirement is acceptable. */ static int uhci_check_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } /* * Reserve a periodic QH's bandwidth in the schedule */ static void uhci_reserve_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } /* * Release a periodic QH's bandwidth reservation */ static void uhci_release_bandwidth(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } static inline struct urb_priv *uhci_alloc_urb_priv(struct uhci_hcd *uhci, struct urb *urb) { … } static void uhci_free_urb_priv(struct uhci_hcd *uhci, struct urb_priv *urbp) { … } /* * Map status to standard result codes * * <status> is (td_status(uhci, td) & 0xF60000), a.k.a. * uhci_status_bits(td_status(uhci, td)). * Note: <status> does not include the TD_CTRL_NAK bit. * <dir_out> is True for output TDs and False for input TDs. */ static int uhci_map_status(int status, int dir_out) { … } /* * Control transfers */ static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb, struct uhci_qh *qh) { … } /* * Common submit for bulk and interrupt */ static int uhci_submit_common(struct uhci_hcd *uhci, struct urb *urb, struct uhci_qh *qh) { … } static int uhci_submit_bulk(struct uhci_hcd *uhci, struct urb *urb, struct uhci_qh *qh) { … } static int uhci_submit_interrupt(struct uhci_hcd *uhci, struct urb *urb, struct uhci_qh *qh) { … } /* * Fix up the data structures following a short transfer */ static int uhci_fixup_short_transfer(struct uhci_hcd *uhci, struct uhci_qh *qh, struct urb_priv *urbp) { … } /* * Common result for control, bulk, and interrupt */ static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb) { … } /* * Isochronous transfers */ static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb, struct uhci_qh *qh) { … } static int uhci_result_isochronous(struct uhci_hcd *uhci, struct urb *urb) { … } static int uhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags) { … } static int uhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) { … } /* * Finish unlinking an URB and give it back */ static void uhci_giveback_urb(struct uhci_hcd *uhci, struct uhci_qh *qh, struct urb *urb, int status) __releases(uhci->lock) __acquires(uhci->lock) { … } /* * Scan the URBs in a QH's queue */ #define QH_FINISHED_UNLINKING(qh) … static void uhci_scan_qh(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } /* * Check for queues that have made some forward progress. * Returns 0 if the queue is not Isochronous, is ACTIVE, and * has not advanced since last examined; 1 otherwise. * * Early Intel controllers have a bug which causes qh->element sometimes * not to advance when a TD completes successfully. The queue remains * stuck on the inactive completed TD. We detect such cases and advance * the element pointer by hand. */ static int uhci_advance_check(struct uhci_hcd *uhci, struct uhci_qh *qh) { … } /* * Process events in the schedule, but only in one thread at a time */ static void uhci_scan_schedule(struct uhci_hcd *uhci) { … }
Codebase Browser
linux