Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6: (100 commits)
  usb-storage: revert DMA-alignment change for Wireless USB
  USB: use reset_resume when normal resume fails
  usb_gadget: composite cdc gadget fault handling
  usb gadget: minor USBCV fix for composite framework
  USB: Fix bug with byte order in isp116x-hcd.c fio write/read
  USB: fix double kfree in ipaq in error case
  USB: fix build error in cdc-acm for CONFIG_PM=n
  USB: remove board-specific UP2OCR configuration from pxa27x-udc
  USB: EHCI: Reconciling USB register differences on MPC85xx vs MPC83xx
  USB: Fix pointer/int cast in USB devio code
  usb gadget: g_cdc dependso on NET
  USB: Au1xxx-usb: suspend/resume support.
  USB: Au1xxx-usb: clean up ohci/ehci bus glue sources.
  usbfs: don't store bad pointers in registration
  usbfs: fix race between open and unregister
  usbfs: simplify the lookup-by-minor routines
  usbfs: send disconnect signals when device is unregistered
  USB: Force unbinding of drivers lacking reset_resume or other methods
  USB: ohci-pnx4008: I2C cleanups and fixes
  USB: debug port converter does not accept more than 8 byte packets
  ...

1 files changed, 205 insertions, 164 deletions

diff --git a/drivers/usb/host/ehci-au1xxx.c b/drivers/usb/host/ehci-au1xxx.c
index 08a4335401a9..bf69f4739107 100644
--- a/drivers/usb/host/ehci-au1xxx.c
+++ b/drivers/usb/host/ehci-au1xxx.c
@@ -19,263 +19,304 @@
 #define USB_MCFG_RDCOMB   (1<<30)
 #define USB_MCFG_SSDEN    (1<<23)
 #define USB_MCFG_PHYPLLEN (1<<19)
+#define USB_MCFG_UCECLKEN (1<<18)
 #define USB_MCFG_EHCCLKEN (1<<17)
+#ifdef CONFIG_DMA_COHERENT
 #define USB_MCFG_UCAM     (1<<7)
+#else
+#define USB_MCFG_UCAM     (0)
+#endif
 #define USB_MCFG_EBMEN    (1<<3)
 #define USB_MCFG_EMEMEN   (1<<2)
 
-#define USBH_ENABLE_CE    (USB_MCFG_PHYPLLEN | USB_MCFG_EHCCLKEN)
+#define USBH_ENABLE_CE  (USB_MCFG_PHYPLLEN | USB_MCFG_EHCCLKEN)
+#define USBH_ENABLE_INIT (USB_MCFG_PFEN  | USB_MCFG_RDCOMB |    \
+                          USBH_ENABLE_CE | USB_MCFG_SSDEN  |    \
+                          USB_MCFG_UCAM  | USB_MCFG_EBMEN  |    \
+                          USB_MCFG_EMEMEN)
 
-#ifdef CONFIG_DMA_COHERENT
-#define USBH_ENABLE_INIT  (USBH_ENABLE_CE \
-                         | USB_MCFG_PFEN | USB_MCFG_RDCOMB \
-                         | USB_MCFG_SSDEN | USB_MCFG_UCAM \
-                         | USB_MCFG_EBMEN | USB_MCFG_EMEMEN)
-#else
-#define USBH_ENABLE_INIT  (USBH_ENABLE_CE \
-                         | USB_MCFG_PFEN | USB_MCFG_RDCOMB \
-                         | USB_MCFG_SSDEN \
-                         | USB_MCFG_EBMEN | USB_MCFG_EMEMEN)
-#endif
 #define USBH_DISABLE      (USB_MCFG_EBMEN | USB_MCFG_EMEMEN)
 
 extern int usb_disabled(void);
 
-/*-------------------------------------------------------------------------*/
-
-static void au1xxx_start_ehc(struct platform_device *dev)
+static void au1xxx_start_ehc(void)
 {
-        pr_debug(__FILE__ ": starting Au1xxx EHCI USB Controller\n");
-
-        /* write HW defaults again in case Yamon cleared them */
-        if (au_readl(USB_HOST_CONFIG) == 0) {
-                au_writel(0x00d02000, USB_HOST_CONFIG);
-                au_readl(USB_HOST_CONFIG);
-                udelay(1000);
-        }
-        /* enable host controller */
-        au_writel(USBH_ENABLE_CE | au_readl(USB_HOST_CONFIG), USB_HOST_CONFIG);
-        au_readl(USB_HOST_CONFIG);
-        udelay(1000);
-        au_writel(USBH_ENABLE_INIT | au_readl(USB_HOST_CONFIG),
-                  USB_HOST_CONFIG);
-        au_readl(USB_HOST_CONFIG);
+        /* enable clock to EHCI block and HS PHY PLL*/
+        au_writel(au_readl(USB_HOST_CONFIG) | USBH_ENABLE_CE, USB_HOST_CONFIG);
+        au_sync();
         udelay(1000);
 
-        pr_debug(__FILE__ ": Clock to USB host has been enabled\n");
+        /* enable EHCI mmio */
+        au_writel(au_readl(USB_HOST_CONFIG) | USBH_ENABLE_INIT, USB_HOST_CONFIG);
+        au_sync();
+        udelay(1000);
 }
 
-static void au1xxx_stop_ehc(struct platform_device *dev)
+static void au1xxx_stop_ehc(void)
 {
-        pr_debug(__FILE__ ": stopping Au1xxx EHCI USB Controller\n");
+        unsigned long c;
 
         /* Disable mem */
-        au_writel(~USBH_DISABLE & au_readl(USB_HOST_CONFIG), USB_HOST_CONFIG);
+        au_writel(au_readl(USB_HOST_CONFIG) & ~USBH_DISABLE, USB_HOST_CONFIG);
+        au_sync();
         udelay(1000);
-        /* Disable clock */
-        au_writel(~USB_MCFG_EHCCLKEN & au_readl(USB_HOST_CONFIG),
-                  USB_HOST_CONFIG);
-        au_readl(USB_HOST_CONFIG);
+
+        /* Disable EHC clock. If the HS PHY is unused disable it too. */
+        c = au_readl(USB_HOST_CONFIG) & ~USB_MCFG_EHCCLKEN;
+        if (!(c & USB_MCFG_UCECLKEN))           /* UDC disabled? */
+                c &= ~USB_MCFG_PHYPLLEN;        /* yes: disable HS PHY PLL */
+        au_writel(c, USB_HOST_CONFIG);
+        au_sync();
 }
 
-/*-------------------------------------------------------------------------*/
+static const struct hc_driver ehci_au1xxx_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "Au1xxx EHCI",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         *
+         * FIXME -- ehci_init() doesn't do enough here.
+         * See ehci-ppc-soc for a complete implementation.
+         */
+        .reset                  = ehci_init,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
 
-/* configure so an HC device and id are always provided */
-/* always called with process context; sleeping is OK */
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
 
-/**
- * usb_ehci_au1xxx_probe - initialize Au1xxx-based HCDs
- * Context: !in_interrupt()
- *
- * Allocates basic resources for this USB host controller, and
- * then invokes the start() method for the HCD associated with it
- * through the hotplug entry's driver_data.
- *
- */
-int usb_ehci_au1xxx_probe(const struct hc_driver *driver,
-                          struct usb_hcd **hcd_out, struct platform_device *dev)
+        /*
+         * scheduling support
+         */
+        .get_frame_number       = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+};
+
+static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
 {
-        int retval;
         struct usb_hcd *hcd;
         struct ehci_hcd *ehci;
+        int ret;
 
-#if defined(CONFIG_SOC_AU1200) && defined(CONFIG_DMA_COHERENT)
+        if (usb_disabled())
+                return -ENODEV;
 
+#if defined(CONFIG_SOC_AU1200) && defined(CONFIG_DMA_COHERENT)
         /* Au1200 AB USB does not support coherent memory */
         if (!(read_c0_prid() & 0xff)) {
-                pr_info("%s: this is chip revision AB!\n", dev->name);
-                pr_info("%s: update your board or re-configure the kernel\n",
-                        dev->name);
+                printk(KERN_INFO "%s: this is chip revision AB!\n", pdev->name);
+                printk(KERN_INFO "%s: update your board or re-configure"
+                                 " the kernel\n", pdev->name);
                 return -ENODEV;
         }
 #endif
 
-        au1xxx_start_ehc(dev);
-
-        if (dev->resource[1].flags != IORESOURCE_IRQ) {
+        if (pdev->resource[1].flags != IORESOURCE_IRQ) {
                 pr_debug("resource[1] is not IORESOURCE_IRQ");
-                retval = -ENOMEM;
+                return -ENOMEM;
         }
-        hcd = usb_create_hcd(driver, &dev->dev, "Au1xxx");
+        hcd = usb_create_hcd(&ehci_au1xxx_hc_driver, &pdev->dev, "Au1xxx");
         if (!hcd)
                 return -ENOMEM;
-        hcd->rsrc_start = dev->resource[0].start;
-        hcd->rsrc_len = dev->resource[0].end - dev->resource[0].start + 1;
+
+        hcd->rsrc_start = pdev->resource[0].start;
+        hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
                 pr_debug("request_mem_region failed");
-                retval = -EBUSY;
+                ret = -EBUSY;
                 goto err1;
         }
 
         hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
         if (!hcd->regs) {
                 pr_debug("ioremap failed");
-                retval = -ENOMEM;
+                ret = -ENOMEM;
                 goto err2;
         }
 
+        au1xxx_start_ehc();
+
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs;
         ehci->regs = hcd->regs + HC_LENGTH(readl(&ehci->caps->hc_capbase));
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = readl(&ehci->caps->hcs_params);
 
-        /* ehci_hcd_init(hcd_to_ehci(hcd)); */
-
-        retval =
-            usb_add_hcd(hcd, dev->resource[1].start, IRQF_DISABLED | IRQF_SHARED);
-        if (retval == 0)
-                return retval;
+        ret = usb_add_hcd(hcd, pdev->resource[1].start,
+                          IRQF_DISABLED | IRQF_SHARED);
+        if (ret == 0) {
+                platform_set_drvdata(pdev, hcd);
+                return ret;
+        }
 
-        au1xxx_stop_ehc(dev);
+        au1xxx_stop_ehc();
         iounmap(hcd->regs);
 err2:
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 err1:
         usb_put_hcd(hcd);
-        return retval;
+        return ret;
 }
 
-/* may be called without controller electrically present */
-/* may be called with controller, bus, and devices active */
-
-/**
- * usb_ehci_hcd_au1xxx_remove - shutdown processing for Au1xxx-based HCDs
- * @dev: USB Host Controller being removed
- * Context: !in_interrupt()
- *
- * Reverses the effect of usb_ehci_hcd_au1xxx_probe(), first invoking
- * the HCD's stop() method.  It is always called from a thread
- * context, normally "rmmod", "apmd", or something similar.
- *
- */
-void usb_ehci_au1xxx_remove(struct usb_hcd *hcd, struct platform_device *dev)
+static int ehci_hcd_au1xxx_drv_remove(struct platform_device *pdev)
 {
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
         usb_remove_hcd(hcd);
         iounmap(hcd->regs);
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
-        au1xxx_stop_ehc(dev);
+        au1xxx_stop_ehc();
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
 }
 
-/*-------------------------------------------------------------------------*/
+#ifdef CONFIG_PM
+static int ehci_hcd_au1xxx_drv_suspend(struct platform_device *pdev,
+                                        pm_message_t message)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        unsigned long flags;
+        int rc;
 
-static const struct hc_driver ehci_au1xxx_hc_driver = {
-        .description = hcd_name,
-        .product_desc = "Au1xxx EHCI",
-        .hcd_priv_size = sizeof(struct ehci_hcd),
+        return 0;
+        rc = 0;
 
-        /*
-         * generic hardware linkage
-         */
-        .irq = ehci_irq,
-        .flags = HCD_MEMORY | HCD_USB2,
+        if (time_before(jiffies, ehci->next_statechange))
+                msleep(10);
 
-        /*
-         * basic lifecycle operations
+        /* Root hub was already suspended. Disable irq emission and
+         * mark HW unaccessible, bail out if RH has been resumed. Use
+         * the spinlock to properly synchronize with possible pending
+         * RH suspend or resume activity.
          *
-         * FIXME -- ehci_init() doesn't do enough here.
-         * See ehci-ppc-soc for a complete implementation.
-         */
-        .reset = ehci_init,
-        .start = ehci_run,
-        .stop = ehci_stop,
-        .shutdown = ehci_shutdown,
-
-        /*
-         * managing i/o requests and associated device resources
+         * This is still racy as hcd->state is manipulated outside of
+         * any locks =P But that will be a different fix.
          */
-        .urb_enqueue = ehci_urb_enqueue,
-        .urb_dequeue = ehci_urb_dequeue,
-        .endpoint_disable = ehci_endpoint_disable,
+        spin_lock_irqsave(&ehci->lock, flags);
+        if (hcd->state != HC_STATE_SUSPENDED) {
+                rc = -EINVAL;
+                goto bail;
+        }
+        ehci_writel(ehci, 0, &ehci->regs->intr_enable);
+        (void)ehci_readl(ehci, &ehci->regs->intr_enable);
 
-        /*
-         * scheduling support
-         */
-        .get_frame_number = ehci_get_frame,
+        /* make sure snapshot being resumed re-enumerates everything */
+        if (message.event == PM_EVENT_PRETHAW) {
+                ehci_halt(ehci);
+                ehci_reset(ehci);
+        }
 
-        /*
-         * root hub support
-         */
-        .hub_status_data = ehci_hub_status_data,
-        .hub_control = ehci_hub_control,
-        .bus_suspend = ehci_bus_suspend,
-        .bus_resume = ehci_bus_resume,
-        .relinquish_port = ehci_relinquish_port,
-        .port_handed_over = ehci_port_handed_over,
-};
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 
-/*-------------------------------------------------------------------------*/
+        au1xxx_stop_ehc();
 
-static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
-{
-        struct usb_hcd *hcd = NULL;
-        int ret;
+bail:
+        spin_unlock_irqrestore(&ehci->lock, flags);
 
-        pr_debug("In ehci_hcd_au1xxx_drv_probe\n");
+        // could save FLADJ in case of Vaux power loss
+        // ... we'd only use it to handle clock skew
 
-        if (usb_disabled())
-                return -ENODEV;
-
-        /* FIXME we only want one one probe() not two */
-        ret = usb_ehci_au1xxx_probe(&ehci_au1xxx_hc_driver, &hcd, pdev);
-        return ret;
+        return rc;
 }
 
-static int ehci_hcd_au1xxx_drv_remove(struct platform_device *pdev)
+
+static int ehci_hcd_au1xxx_drv_resume(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 
-        /* FIXME we only want one one remove() not two */
-        usb_ehci_au1xxx_remove(hcd, pdev);
-        return 0;
-}
+        au1xxx_start_ehc();
 
- /*TBD*/
-/*static int ehci_hcd_au1xxx_drv_suspend(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        // maybe restore FLADJ
 
-        return 0;
-}
-static int ehci_hcd_au1xxx_drv_resume(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        if (time_before(jiffies, ehci->next_statechange))
+                msleep(100);
+
+        /* Mark hardware accessible again as we are out of D3 state by now */
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        /* If CF is still set, we maintained PCI Vaux power.
+         * Just undo the effect of ehci_pci_suspend().
+         */
+        if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF) {
+                int     mask = INTR_MASK;
+
+                if (!hcd->self.root_hub->do_remote_wakeup)
+                        mask &= ~STS_PCD;
+                ehci_writel(ehci, mask, &ehci->regs->intr_enable);
+                ehci_readl(ehci, &ehci->regs->intr_enable);
+                return 0;
+        }
+
+        ehci_dbg(ehci, "lost power, restarting\n");
+        usb_root_hub_lost_power(hcd->self.root_hub);
+
+        /* Else reset, to cope with power loss or flush-to-storage
+         * style "resume" having let BIOS kick in during reboot.
+         */
+        (void) ehci_halt(ehci);
+        (void) ehci_reset(ehci);
+
+        /* emptying the schedule aborts any urbs */
+        spin_lock_irq(&ehci->lock);
+        if (ehci->reclaim)
+                end_unlink_async(ehci);
+        ehci_work(ehci);
+        spin_unlock_irq(&ehci->lock);
+
+        ehci_writel(ehci, ehci->command, &ehci->regs->command);
+        ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
+        ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
+
+        /* here we "know" root ports should always stay powered */
+        ehci_port_power(ehci, 1);
+
+        hcd->state = HC_STATE_SUSPENDED;
 
         return 0;
 }
-*/
-MODULE_ALIAS("platform:au1xxx-ehci");
+
+#else
+#define ehci_hcd_au1xxx_drv_suspend NULL
+#define ehci_hcd_au1xxx_drv_resume NULL
+#endif
+
 static struct platform_driver ehci_hcd_au1xxx_driver = {
-        .probe = ehci_hcd_au1xxx_drv_probe,
-        .remove = ehci_hcd_au1xxx_drv_remove,
-        .shutdown = usb_hcd_platform_shutdown,
-        /*.suspend      = ehci_hcd_au1xxx_drv_suspend, */
-        /*.resume       = ehci_hcd_au1xxx_drv_resume, */
+        .probe          = ehci_hcd_au1xxx_drv_probe,
+        .remove         = ehci_hcd_au1xxx_drv_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .suspend        = ehci_hcd_au1xxx_drv_suspend,
+        .resume         = ehci_hcd_au1xxx_drv_resume,
         .driver = {
-                .name = "au1xxx-ehci",
+                .name   = "au1xxx-ehci",
+                .owner  = THIS_MODULE,
         }
 };
+
+MODULE_ALIAS("platform:au1xxx-ehci");