xHCI: add XHCI_RESET_ON_RESUME quirk for VIA xHCI host

[linux-flexiantxendom0.git] / drivers / usb / host / xhci-pci.c

diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 732837e..211296a 100644 (file)
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -22,6 +22,7 @@
 
 #include <linux/pci.h>
 #include <linux/slab.h>
+#include <linux/module.h>
 
 #include "xhci.h"
 
@@ -51,61 +52,9 @@ static int xhci_pci_reinit(struct xhci_hcd *xhci, struct pci_dev *pdev)
        return 0;
 }
 
-/* called during probe() after chip reset completes */
-static int xhci_pci_setup(struct usb_hcd *hcd)
+static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
 {
-       struct xhci_hcd         *xhci;
-       struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
-       int                     retval;
-       u32                     temp;
-
-       hcd->self.sg_tablesize = TRBS_PER_SEGMENT - 2;
-
-       if (usb_hcd_is_primary_hcd(hcd)) {
-               xhci = kzalloc(sizeof(struct xhci_hcd), GFP_KERNEL);
-               if (!xhci)
-                       return -ENOMEM;
-               *((struct xhci_hcd **) hcd->hcd_priv) = xhci;
-               xhci->main_hcd = hcd;
-               /* Mark the first roothub as being USB 2.0.
-                * The xHCI driver will register the USB 3.0 roothub.
-                */
-               hcd->speed = HCD_USB2;
-               hcd->self.root_hub->speed = USB_SPEED_HIGH;
-               /*
-                * USB 2.0 roothub under xHCI has an integrated TT,
-                * (rate matching hub) as opposed to having an OHCI/UHCI
-                * companion controller.
-                */
-               hcd->has_tt = 1;
-       } else {
-               /* xHCI private pointer was set in xhci_pci_probe for the second
-                * registered roothub.
-                */
-               xhci = hcd_to_xhci(hcd);
-               temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
-               if (HCC_64BIT_ADDR(temp)) {
-                       xhci_dbg(xhci, "Enabling 64-bit DMA addresses.\n");
-                       dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64));
-               } else {
-                       dma_set_mask(hcd->self.controller, DMA_BIT_MASK(32));
-               }
-               return 0;
-       }
-
-       xhci->cap_regs = hcd->regs;
-       xhci->op_regs = hcd->regs +
-               HC_LENGTH(xhci_readl(xhci, &xhci->cap_regs->hc_capbase));
-       xhci->run_regs = hcd->regs +
-               (xhci_readl(xhci, &xhci->cap_regs->run_regs_off) & RTSOFF_MASK);
-       /* Cache read-only capability registers */
-       xhci->hcs_params1 = xhci_readl(xhci, &xhci->cap_regs->hcs_params1);
-       xhci->hcs_params2 = xhci_readl(xhci, &xhci->cap_regs->hcs_params2);
-       xhci->hcs_params3 = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);
-       xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);
-       xhci->hci_version = HC_VERSION(xhci->hcc_params);
-       xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
-       xhci_print_registers(xhci);
+       struct pci_dev          *pdev = to_pci_dev(dev);
 
        /* Look for vendor-specific quirks */
        if (pdev->vendor == PCI_VENDOR_ID_FRESCO_LOGIC &&
@@ -146,33 +95,24 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
                xhci->quirks |= XHCI_RESET_ON_RESUME;
                xhci_dbg(xhci, "QUIRK: Resetting on resume\n");
        }
+       if (pdev->vendor == PCI_VENDOR_ID_VIA)
+               xhci->quirks |= XHCI_RESET_ON_RESUME;
+}
 
-       /* Make sure the HC is halted. */
-       retval = xhci_halt(xhci);
-       if (retval)
-               goto error;
+/* called during probe() after chip reset completes */
+static int xhci_pci_setup(struct usb_hcd *hcd)
+{
+       struct xhci_hcd         *xhci;
+       struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
+       int                     retval;
 
-       xhci_dbg(xhci, "Resetting HCD\n");
-       /* Reset the internal HC memory state and registers. */
-       retval = xhci_reset(xhci);
+       retval = xhci_gen_setup(hcd, xhci_pci_quirks);
        if (retval)
-               goto error;
-       xhci_dbg(xhci, "Reset complete\n");
-
-       temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
-       if (HCC_64BIT_ADDR(temp)) {
-               xhci_dbg(xhci, "Enabling 64-bit DMA addresses.\n");
-               dma_set_mask(hcd->self.controller, DMA_BIT_MASK(64));
-       } else {
-               dma_set_mask(hcd->self.controller, DMA_BIT_MASK(32));
-       }
+               return retval;
 
-       xhci_dbg(xhci, "Calling HCD init\n");
-       /* Initialize HCD and host controller data structures. */
-       retval = xhci_init(hcd);
-       if (retval)
-               goto error;
-       xhci_dbg(xhci, "Called HCD init\n");
+       xhci = hcd_to_xhci(hcd);
+       if (!usb_hcd_is_primary_hcd(hcd))
+               return 0;
 
        pci_read_config_byte(pdev, XHCI_SBRN_OFFSET, &xhci->sbrn);
        xhci_dbg(xhci, "Got SBRN %u\n", (unsigned int) xhci->sbrn);
@@ -182,7 +122,6 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
        if (!retval)
                return retval;
 
-error:
        kfree(xhci);
        return retval;
 }
@@ -384,12 +323,12 @@ static struct pci_driver xhci_pci_driver = {
 #endif
 };
 
-int xhci_register_pci(void)
+int __init xhci_register_pci(void)
 {
        return pci_register_driver(&xhci_pci_driver);
 }
 
-void xhci_unregister_pci(void)
+void __exit xhci_unregister_pci(void)
 {
        pci_unregister_driver(&xhci_pci_driver);
 }