// 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] * * Intel documents this fairly well, and as far as I know there * are no royalties or anything like that, but even so there are * people who decided that they want to do the same thing in a * completely different way. * */ #include <linux/module.h> #include <linux/pci.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/delay.h> #include <linux/ioport.h> #include <linux/slab.h> #include <linux/errno.h> #include <linux/unistd.h> #include <linux/interrupt.h> #include <linux/spinlock.h> #include <linux/debugfs.h> #include <linux/pm.h> #include <linux/dmapool.h> #include <linux/dma-mapping.h> #include <linux/usb.h> #include <linux/usb/hcd.h> #include <linux/bitops.h> #include <linux/dmi.h> #include <linux/uaccess.h> #include <asm/io.h> #include <asm/irq.h> #include "uhci-hcd.h" /* * Version Information */ #define DRIVER_AUTHOR … #define DRIVER_DESC … /* for flakey hardware, ignore overcurrent indicators */ static bool ignore_oc; module_param(ignore_oc, bool, S_IRUGO); MODULE_PARM_DESC(…) …; /* * debug = 0, no debugging messages * debug = 1, dump failed URBs except for stalls * debug = 2, dump all failed URBs (including stalls) * show all queues in /sys/kernel/debug/uhci/[pci_addr] * debug = 3, show all TDs in URBs when dumping */ #ifdef CONFIG_DYNAMIC_DEBUG static int debug = …; module_param(debug, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(…) …; static char *errbuf; #else #define debug … #define errbuf … #endif #define ERRBUF_LEN … static struct kmem_cache *uhci_up_cachep; /* urb_priv */ static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state); static void wakeup_rh(struct uhci_hcd *uhci); static void uhci_get_current_frame_number(struct uhci_hcd *uhci); /* * Calculate the link pointer DMA value for the first Skeleton QH in a frame. */ static __hc32 uhci_frame_skel_link(struct uhci_hcd *uhci, int frame) { … } #include "uhci-debug.c" #include "uhci-q.c" #include "uhci-hub.c" /* * Finish up a host controller reset and update the recorded state. */ static void finish_reset(struct uhci_hcd *uhci) { … } /* * Last rites for a defunct/nonfunctional controller * or one we don't want to use any more. */ static void uhci_hc_died(struct uhci_hcd *uhci) { … } /* * Initialize a controller that was newly discovered or has lost power * or otherwise been reset while it was suspended. In none of these cases * can we be sure of its previous state. */ static void check_and_reset_hc(struct uhci_hcd *uhci) { … } #if defined(CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC) /* * The two functions below are generic reset functions that are used on systems * that do not have keyboard and mouse legacy support. We assume that we are * running on such a system if CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC is defined. */ /* * Make sure the controller is completely inactive, unable to * generate interrupts or do DMA. */ static void uhci_generic_reset_hc(struct uhci_hcd *uhci) { /* Reset the HC - this will force us to get a * new notification of any already connected * ports due to the virtual disconnect that it * implies. */ uhci_writew(uhci, USBCMD_HCRESET, USBCMD); mb(); udelay(5); if (uhci_readw(uhci, USBCMD) & USBCMD_HCRESET) dev_warn(uhci_dev(uhci), "HCRESET not completed yet!\n"); /* Just to be safe, disable interrupt requests and * make sure the controller is stopped. */ uhci_writew(uhci, 0, USBINTR); uhci_writew(uhci, 0, USBCMD); } /* * Initialize a controller that was newly discovered or has just been * resumed. In either case we can't be sure of its previous state. * * Returns: 1 if the controller was reset, 0 otherwise. */ static int uhci_generic_check_and_reset_hc(struct uhci_hcd *uhci) { unsigned int cmd, intr; /* * When restarting a suspended controller, we expect all the * settings to be the same as we left them: * * Controller is stopped and configured with EGSM set; * No interrupts enabled except possibly Resume Detect. * * If any of these conditions are violated we do a complete reset. */ cmd = uhci_readw(uhci, USBCMD); if ((cmd & USBCMD_RS) || !(cmd & USBCMD_CF) || !(cmd & USBCMD_EGSM)) { dev_dbg(uhci_dev(uhci), "%s: cmd = 0x%04x\n", __func__, cmd); goto reset_needed; } intr = uhci_readw(uhci, USBINTR); if (intr & (~USBINTR_RESUME)) { dev_dbg(uhci_dev(uhci), "%s: intr = 0x%04x\n", __func__, intr); goto reset_needed; } return 0; reset_needed: dev_dbg(uhci_dev(uhci), "Performing full reset\n"); uhci_generic_reset_hc(uhci); return 1; } #endif /* CONFIG_USB_UHCI_SUPPORT_NON_PCI_HC */ /* * Store the basic register settings needed by the controller. */ static void configure_hc(struct uhci_hcd *uhci) { … } static int resume_detect_interrupts_are_broken(struct uhci_hcd *uhci) { … } static int global_suspend_mode_is_broken(struct uhci_hcd *uhci) { … } static void suspend_rh(struct uhci_hcd *uhci, enum uhci_rh_state new_state) __releases(uhci->lock) __acquires(uhci->lock) { … } static void start_rh(struct uhci_hcd *uhci) { … } static void wakeup_rh(struct uhci_hcd *uhci) __releases(uhci->lock) __acquires(uhci->lock) { … } static irqreturn_t uhci_irq(struct usb_hcd *hcd) { … } /* * Store the current frame number in uhci->frame_number if the controller * is running. Expand from 11 bits (of which we use only 10) to a * full-sized integer. * * Like many other parts of the driver, this code relies on being polled * more than once per second as long as the controller is running. */ static void uhci_get_current_frame_number(struct uhci_hcd *uhci) { … } /* * De-allocate all resources */ static void release_uhci(struct uhci_hcd *uhci) { … } /* * Allocate a frame list, and then setup the skeleton * * The hardware doesn't really know any difference * in the queues, but the order does matter for the * protocols higher up. The order in which the queues * are encountered by the hardware is: * * - All isochronous events are handled before any * of the queues. We don't do that here, because * we'll create the actual TD entries on demand. * - The first queue is the high-period interrupt queue. * - The second queue is the period-1 interrupt and async * (low-speed control, full-speed control, then bulk) queue. * - The third queue is the terminating bandwidth reclamation queue, * which contains no members, loops back to itself, and is present * only when FSBR is on and there are no full-speed control or bulk QHs. */ static int uhci_start(struct usb_hcd *hcd) { … } static void uhci_stop(struct usb_hcd *hcd) { … } #ifdef CONFIG_PM static int uhci_rh_suspend(struct usb_hcd *hcd) { … } static int uhci_rh_resume(struct usb_hcd *hcd) { … } #endif /* Wait until a particular device/endpoint's QH is idle, and free it */ static void uhci_hcd_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *hep) { … } static int uhci_hcd_get_frame_number(struct usb_hcd *hcd) { … } /* Determines number of ports on controller */ static int uhci_count_ports(struct usb_hcd *hcd) { … } static const char hcd_name[] = …; #if defined(CONFIG_USB_PCI) && defined(CONFIG_HAS_IOPORT) #include "uhci-pci.c" #define PCI_DRIVER … #endif #ifdef CONFIG_SPARC_LEON #include "uhci-grlib.c" #define PLATFORM_DRIVER … #endif #ifdef CONFIG_USB_UHCI_PLATFORM #include "uhci-platform.c" #define PLATFORM_DRIVER … #endif #if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) #error "missing bus glue for uhci-hcd" #endif static int __init uhci_hcd_init(void) { … } static void __exit uhci_hcd_cleanup(void) { … } module_init(…) …; module_exit(uhci_hcd_cleanup); MODULE_AUTHOR(…); MODULE_DESCRIPTION(…); MODULE_LICENSE(…) …;
Codebase Browser
linux