Merge tag 'usb-3.9-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb

Pull USB patches from Greg Kroah-Hartman:
 "Here's the big USB merge for 3.9-rc1

  Nothing major, lots of gadget fixes, and of course, xhci stuff.

  All of this has been in linux-next for a while, with the exception of
  the last 3 patches, which were reverts of patches in the tree that
  caused problems, they went in yesterday."

* tag 'usb-3.9-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (190 commits)
  Revert "USB: EHCI: make ehci-vt8500 a separate driver"
  Revert "USB: EHCI: make ehci-orion a separate driver"
  Revert "USB: update host controller Kconfig entries"
  USB: update host controller Kconfig entries
  USB: EHCI: make ehci-orion a separate driver
  USB: EHCI: make ehci-vt8500 a separate driver
  USB: usb-storage: unusual_devs update for Super TOP SATA bridge
  USB: ehci-omap: Fix autoloading of module
  USB: ehci-omap: Don't free gpios that we didn't request
  USB: option: add Huawei "ACM" devices using protocol = vendor
  USB: serial: fix null-pointer dereferences on disconnect
  USB: option: add Yota / Megafon M100-1 4g modem
  drivers/usb: add missing GENERIC_HARDIRQS dependencies
  USB: storage: properly handle the endian issues of idProduct
  testusb: remove all mentions of 'usbfs'
  usb: gadget: imx_udc: make it depend on BROKEN
  usb: omap_control_usb: fix compile warning
  ARM: OMAP: USB: Add phy binding information
  ARM: OMAP2: MUSB: Specify omap4 has mailbox
  ARM: OMAP: devices: create device for usb part of control module
  ...

14 files changed, 269 insertions, 160 deletions

diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 3a21c5d683c0..c59a1126926f 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -246,7 +246,7 @@ config USB_EHCI_ATH79
 
 config USB_OXU210HP_HCD
         tristate "OXU210HP HCD support"
-        depends on USB
+        depends on USB && GENERIC_HARDIRQS
         ---help---
           The OXU210HP is an USB host/OTG/device controller. Enable this
           option if your board has this chip. If unsure, say N.
diff --git a/drivers/usb/host/ehci-mv.c b/drivers/usb/host/ehci-mv.c
index 6c56297ea16b..3065809546b1 100644
--- a/drivers/usb/host/ehci-mv.c
+++ b/drivers/usb/host/ehci-mv.c
@@ -302,7 +302,6 @@ static int mv_ehci_remove(struct platform_device *pdev)
 {
         struct ehci_hcd_mv *ehci_mv = platform_get_drvdata(pdev);
         struct usb_hcd *hcd = ehci_mv->hcd;
-        int clk_i;
 
         if (hcd->rh_registered)
                 usb_remove_hcd(hcd);
diff --git a/drivers/usb/host/ehci-mxc.c b/drivers/usb/host/ehci-mxc.c
index e2004de6ad3d..e9301fb97eaa 100644
--- a/drivers/usb/host/ehci-mxc.c
+++ b/drivers/usb/host/ehci-mxc.c
@@ -57,7 +57,6 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         struct usb_hcd *hcd;
         struct resource *res;
         int irq, ret;
-        unsigned int flags;
         struct ehci_mxc_priv *priv;
         struct device *dev = &pdev->dev;
         struct ehci_hcd *ehci;
@@ -162,25 +161,6 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         if (ret)
                 goto err_add;
 
-        if (pdata->otg) {
-                /*
-                 * efikamx and efikasb have some hardware bug which is
-                 * preventing usb to work unless CHRGVBUS is set.
-                 * It's in violation of USB specs
-                 */
-                if (machine_is_mx51_efikamx() || machine_is_mx51_efikasb()) {
-                        flags = usb_phy_io_read(pdata->otg,
-                                                        ULPI_OTG_CTRL);
-                        flags |= ULPI_OTG_CTRL_CHRGVBUS;
-                        ret = usb_phy_io_write(pdata->otg, flags,
-                                                        ULPI_OTG_CTRL);
-                        if (ret) {
-                                dev_err(dev, "unable to set CHRVBUS\n");
-                                goto err_add;
-                        }
-                }
-        }
-
         return 0;
 
 err_add:
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index ac17a7c3a0cd..99899e808c6a 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -288,7 +288,6 @@ static int ehci_hcd_omap_remove(struct platform_device *pdev)
 {
         struct device *dev                              = &pdev->dev;
         struct usb_hcd *hcd                             = dev_get_drvdata(dev);
-        struct ehci_hcd_omap_platform_data *pdata       = dev->platform_data;
 
         usb_remove_hcd(hcd);
         disable_put_regulator(dev->platform_data);
@@ -298,13 +297,6 @@ static int ehci_hcd_omap_remove(struct platform_device *pdev)
         pm_runtime_put_sync(dev);
         pm_runtime_disable(dev);
 
-        if (pdata->phy_reset) {
-                if (gpio_is_valid(pdata->reset_gpio_port[0]))
-                        gpio_free(pdata->reset_gpio_port[0]);
-
-                if (gpio_is_valid(pdata->reset_gpio_port[1]))
-                        gpio_free(pdata->reset_gpio_port[1]);
-        }
         return 0;
 }
 
@@ -372,7 +364,7 @@ static const struct hc_driver ehci_omap_hc_driver = {
         .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
 };
 
-MODULE_ALIAS("platform:omap-ehci");
+MODULE_ALIAS("platform:ehci-omap");
 MODULE_AUTHOR("Texas Instruments, Inc.");
 MODULE_AUTHOR("Felipe Balbi <felipe.balbi@nokia.com>");
 
diff --git a/drivers/usb/host/ehci-s5p.c b/drivers/usb/host/ehci-s5p.c
index 319dcfaa8735..20ebf6a8b7f4 100644
--- a/drivers/usb/host/ehci-s5p.c
+++ b/drivers/usb/host/ehci-s5p.c
@@ -17,6 +17,8 @@
 #include <linux/platform_device.h>
 #include <linux/of_gpio.h>
 #include <linux/platform_data/usb-ehci-s5p.h>
+#include <linux/usb/phy.h>
+#include <linux/usb/samsung_usb_phy.h>
 #include <plat/usb-phy.h>
 
 #define EHCI_INSNREG00(base)                    (base + 0x90)
@@ -32,6 +34,9 @@ struct s5p_ehci_hcd {
         struct device *dev;
         struct usb_hcd *hcd;
         struct clk *clk;
+        struct usb_phy *phy;
+        struct usb_otg *otg;
+        struct s5p_ehci_platdata *pdata;
 };
 
 static const struct hc_driver s5p_ehci_hc_driver = {
@@ -65,6 +70,26 @@ static const struct hc_driver s5p_ehci_hc_driver = {
         .clear_tt_buffer_complete       = ehci_clear_tt_buffer_complete,
 };
 
+static void s5p_ehci_phy_enable(struct s5p_ehci_hcd *s5p_ehci)
+{
+        struct platform_device *pdev = to_platform_device(s5p_ehci->dev);
+
+        if (s5p_ehci->phy)
+                usb_phy_init(s5p_ehci->phy);
+        else if (s5p_ehci->pdata->phy_init)
+                s5p_ehci->pdata->phy_init(pdev, USB_PHY_TYPE_HOST);
+}
+
+static void s5p_ehci_phy_disable(struct s5p_ehci_hcd *s5p_ehci)
+{
+        struct platform_device *pdev = to_platform_device(s5p_ehci->dev);
+
+        if (s5p_ehci->phy)
+                usb_phy_shutdown(s5p_ehci->phy);
+        else if (s5p_ehci->pdata->phy_exit)
+                s5p_ehci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);
+}
+
 static void s5p_setup_vbus_gpio(struct platform_device *pdev)
 {
         int err;
@@ -87,20 +112,15 @@ static u64 ehci_s5p_dma_mask = DMA_BIT_MASK(32);
 
 static int s5p_ehci_probe(struct platform_device *pdev)
 {
-        struct s5p_ehci_platdata *pdata;
+        struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
         struct s5p_ehci_hcd *s5p_ehci;
         struct usb_hcd *hcd;
         struct ehci_hcd *ehci;
         struct resource *res;
+        struct usb_phy *phy;
         int irq;
         int err;
 
-        pdata = pdev->dev.platform_data;
-        if (!pdata) {
-                dev_err(&pdev->dev, "No platform data defined\n");
-                return -EINVAL;
-        }
-
         /*
          * Right now device-tree probed devices don't get dma_mask set.
          * Since shared usb code relies on it, set it here for now.
@@ -118,6 +138,20 @@ static int s5p_ehci_probe(struct platform_device *pdev)
         if (!s5p_ehci)
                 return -ENOMEM;
 
+        phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
+        if (IS_ERR_OR_NULL(phy)) {
+                /* Fallback to pdata */
+                if (!pdata) {
+                        dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
+                        return -EPROBE_DEFER;
+                } else {
+                        s5p_ehci->pdata = pdata;
+                }
+        } else {
+                s5p_ehci->phy = phy;
+                s5p_ehci->otg = phy->otg;
+        }
+
         s5p_ehci->dev = &pdev->dev;
 
         hcd = usb_create_hcd(&s5p_ehci_hc_driver, &pdev->dev,
@@ -163,8 +197,10 @@ static int s5p_ehci_probe(struct platform_device *pdev)
                 goto fail_io;
         }
 
-        if (pdata->phy_init)
-                pdata->phy_init(pdev, S5P_USB_PHY_HOST);
+        if (s5p_ehci->otg)
+                s5p_ehci->otg->set_host(s5p_ehci->otg, &s5p_ehci->hcd->self);
+
+        s5p_ehci_phy_enable(s5p_ehci);
 
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs;
@@ -175,13 +211,15 @@ static int s5p_ehci_probe(struct platform_device *pdev)
         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err) {
                 dev_err(&pdev->dev, "Failed to add USB HCD\n");
-                goto fail_io;
+                goto fail_add_hcd;
         }
 
         platform_set_drvdata(pdev, s5p_ehci);
 
         return 0;
 
+fail_add_hcd:
+        s5p_ehci_phy_disable(s5p_ehci);
 fail_io:
         clk_disable_unprepare(s5p_ehci->clk);
 fail_clk:
@@ -191,14 +229,15 @@ fail_clk:
 
 static int s5p_ehci_remove(struct platform_device *pdev)
 {
-        struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
         struct s5p_ehci_hcd *s5p_ehci = platform_get_drvdata(pdev);
         struct usb_hcd *hcd = s5p_ehci->hcd;
 
         usb_remove_hcd(hcd);
 
-        if (pdata && pdata->phy_exit)
-                pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
+        if (s5p_ehci->otg)
+                s5p_ehci->otg->set_host(s5p_ehci->otg, &s5p_ehci->hcd->self);
+
+        s5p_ehci_phy_disable(s5p_ehci);
 
         clk_disable_unprepare(s5p_ehci->clk);
 
@@ -222,14 +261,14 @@ static int s5p_ehci_suspend(struct device *dev)
         struct s5p_ehci_hcd *s5p_ehci = dev_get_drvdata(dev);
         struct usb_hcd *hcd = s5p_ehci->hcd;
         bool do_wakeup = device_may_wakeup(dev);
-        struct platform_device *pdev = to_platform_device(dev);
-        struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
         int rc;
 
         rc = ehci_suspend(hcd, do_wakeup);
 
-        if (pdata && pdata->phy_exit)
-                pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
+        if (s5p_ehci->otg)
+                s5p_ehci->otg->set_host(s5p_ehci->otg, &s5p_ehci->hcd->self);
+
+        s5p_ehci_phy_disable(s5p_ehci);
 
         clk_disable_unprepare(s5p_ehci->clk);
 
@@ -240,13 +279,13 @@ static int s5p_ehci_resume(struct device *dev)
 {
         struct s5p_ehci_hcd *s5p_ehci = dev_get_drvdata(dev);
         struct usb_hcd *hcd = s5p_ehci->hcd;
-        struct platform_device *pdev = to_platform_device(dev);
-        struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
 
         clk_prepare_enable(s5p_ehci->clk);
 
-        if (pdata && pdata->phy_init)
-                pdata->phy_init(pdev, S5P_USB_PHY_HOST);
+        if (s5p_ehci->otg)
+                s5p_ehci->otg->set_host(s5p_ehci->otg, &s5p_ehci->hcd->self);
+
+        s5p_ehci_phy_enable(s5p_ehci);
 
         /* DMA burst Enable */
         writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs));
@@ -266,7 +305,7 @@ static const struct dev_pm_ops s5p_ehci_pm_ops = {
 
 #ifdef CONFIG_OF
 static const struct of_device_id exynos_ehci_match[] = {
-        { .compatible = "samsung,exynos-ehci" },
+        { .compatible = "samsung,exynos4210-ehci" },
         {},
 };
 MODULE_DEVICE_TABLE(of, exynos_ehci_match);
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index a35bbddf8968..125e261f5bfc 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -932,7 +932,7 @@ static void enqueue_qtds(struct usb_hcd *hcd, struct isp1760_qh *qh)
         }
 }
 
-void schedule_ptds(struct usb_hcd *hcd)
+static void schedule_ptds(struct usb_hcd *hcd)
 {
         struct isp1760_hcd *priv;
         struct isp1760_qh *qh, *qh_next;
@@ -1285,7 +1285,7 @@ leave:
 #define SLOT_CHECK_PERIOD 200
 static struct timer_list errata2_timer;
 
-void errata2_function(unsigned long data)
+static void errata2_function(unsigned long data)
 {
         struct usb_hcd *hcd = (struct usb_hcd *) data;
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
diff --git a/drivers/usb/host/ohci-exynos.c b/drivers/usb/host/ohci-exynos.c
index aa3b8844bb9f..e3b7e85120e4 100644
--- a/drivers/usb/host/ohci-exynos.c
+++ b/drivers/usb/host/ohci-exynos.c
@@ -15,14 +15,39 @@
 #include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/platform_data/usb-exynos.h>
+#include <linux/usb/phy.h>
+#include <linux/usb/samsung_usb_phy.h>
 #include <plat/usb-phy.h>
 
 struct exynos_ohci_hcd {
         struct device *dev;
         struct usb_hcd *hcd;
         struct clk *clk;
+        struct usb_phy *phy;
+        struct usb_otg *otg;
+        struct exynos4_ohci_platdata *pdata;
 };
 
+static void exynos_ohci_phy_enable(struct exynos_ohci_hcd *exynos_ohci)
+{
+        struct platform_device *pdev = to_platform_device(exynos_ohci->dev);
+
+        if (exynos_ohci->phy)
+                usb_phy_init(exynos_ohci->phy);
+        else if (exynos_ohci->pdata->phy_init)
+                exynos_ohci->pdata->phy_init(pdev, USB_PHY_TYPE_HOST);
+}
+
+static void exynos_ohci_phy_disable(struct exynos_ohci_hcd *exynos_ohci)
+{
+        struct platform_device *pdev = to_platform_device(exynos_ohci->dev);
+
+        if (exynos_ohci->phy)
+                usb_phy_shutdown(exynos_ohci->phy);
+        else if (exynos_ohci->pdata->phy_exit)
+                exynos_ohci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);
+}
+
 static int ohci_exynos_reset(struct usb_hcd *hcd)
 {
         return ohci_init(hcd_to_ohci(hcd));
@@ -78,20 +103,15 @@ static u64 ohci_exynos_dma_mask = DMA_BIT_MASK(32);
 
 static int exynos_ohci_probe(struct platform_device *pdev)
 {
-        struct exynos4_ohci_platdata *pdata;
+        struct exynos4_ohci_platdata *pdata = pdev->dev.platform_data;
         struct exynos_ohci_hcd *exynos_ohci;
         struct usb_hcd *hcd;
         struct ohci_hcd *ohci;
         struct resource *res;
+        struct usb_phy *phy;
         int irq;
         int err;
 
-        pdata = pdev->dev.platform_data;
-        if (!pdata) {
-                dev_err(&pdev->dev, "No platform data defined\n");
-                return -EINVAL;
-        }
-
         /*
          * Right now device-tree probed devices don't get dma_mask set.
          * Since shared usb code relies on it, set it here for now.
@@ -107,6 +127,20 @@ static int exynos_ohci_probe(struct platform_device *pdev)
         if (!exynos_ohci)
                 return -ENOMEM;
 
+        phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
+        if (IS_ERR_OR_NULL(phy)) {
+                /* Fallback to pdata */
+                if (!pdata) {
+                        dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
+                        return -EPROBE_DEFER;
+                } else {
+                        exynos_ohci->pdata = pdata;
+                }
+        } else {
+                exynos_ohci->phy = phy;
+                exynos_ohci->otg = phy->otg;
+        }
+
         exynos_ohci->dev = &pdev->dev;
 
         hcd = usb_create_hcd(&exynos_ohci_hc_driver, &pdev->dev,
@@ -152,8 +186,11 @@ static int exynos_ohci_probe(struct platform_device *pdev)
                 goto fail_io;
         }
 
-        if (pdata->phy_init)
-                pdata->phy_init(pdev, S5P_USB_PHY_HOST);
+        if (exynos_ohci->otg)
+                exynos_ohci->otg->set_host(exynos_ohci->otg,
+                                        &exynos_ohci->hcd->self);
+
+        exynos_ohci_phy_enable(exynos_ohci);
 
         ohci = hcd_to_ohci(hcd);
         ohci_hcd_init(ohci);
@@ -161,13 +198,15 @@ static int exynos_ohci_probe(struct platform_device *pdev)
         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err) {
                 dev_err(&pdev->dev, "Failed to add USB HCD\n");
-                goto fail_io;
+                goto fail_add_hcd;
         }
 
         platform_set_drvdata(pdev, exynos_ohci);
 
         return 0;
 
+fail_add_hcd:
+        exynos_ohci_phy_disable(exynos_ohci);
 fail_io:
         clk_disable_unprepare(exynos_ohci->clk);
 fail_clk:
@@ -177,14 +216,16 @@ fail_clk:
 
 static int exynos_ohci_remove(struct platform_device *pdev)
 {
-        struct exynos4_ohci_platdata *pdata = pdev->dev.platform_data;
         struct exynos_ohci_hcd *exynos_ohci = platform_get_drvdata(pdev);
         struct usb_hcd *hcd = exynos_ohci->hcd;
 
         usb_remove_hcd(hcd);
 
-        if (pdata && pdata->phy_exit)
-                pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
+        if (exynos_ohci->otg)
+                exynos_ohci->otg->set_host(exynos_ohci->otg,
+                                        &exynos_ohci->hcd->self);
+
+        exynos_ohci_phy_disable(exynos_ohci);
 
         clk_disable_unprepare(exynos_ohci->clk);
 
@@ -208,8 +249,6 @@ static int exynos_ohci_suspend(struct device *dev)
         struct exynos_ohci_hcd *exynos_ohci = dev_get_drvdata(dev);
         struct usb_hcd *hcd = exynos_ohci->hcd;
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        struct platform_device *pdev = to_platform_device(dev);
-        struct exynos4_ohci_platdata *pdata = pdev->dev.platform_data;
         unsigned long flags;
         int rc = 0;
 
@@ -228,8 +267,11 @@ static int exynos_ohci_suspend(struct device *dev)
 
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 
-        if (pdata && pdata->phy_exit)
-                pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
+        if (exynos_ohci->otg)
+                exynos_ohci->otg->set_host(exynos_ohci->otg,
+                                        &exynos_ohci->hcd->self);
+
+        exynos_ohci_phy_disable(exynos_ohci);
 
         clk_disable_unprepare(exynos_ohci->clk);
 
@@ -243,13 +285,14 @@ static int exynos_ohci_resume(struct device *dev)
 {
         struct exynos_ohci_hcd *exynos_ohci = dev_get_drvdata(dev);
         struct usb_hcd *hcd = exynos_ohci->hcd;
-        struct platform_device *pdev = to_platform_device(dev);
-        struct exynos4_ohci_platdata *pdata = pdev->dev.platform_data;
 
         clk_prepare_enable(exynos_ohci->clk);
 
-        if (pdata && pdata->phy_init)
-                pdata->phy_init(pdev, S5P_USB_PHY_HOST);
+        if (exynos_ohci->otg)
+                exynos_ohci->otg->set_host(exynos_ohci->otg,
+                                        &exynos_ohci->hcd->self);
+
+        exynos_ohci_phy_enable(exynos_ohci);
 
         ohci_resume(hcd, false);
 
@@ -267,7 +310,7 @@ static const struct dev_pm_ops exynos_ohci_pm_ops = {
 
 #ifdef CONFIG_OF
 static const struct of_device_id exynos_ohci_match[] = {
-        { .compatible = "samsung,exynos-ohci" },
+        { .compatible = "samsung,exynos4210-ohci" },
         {},
 };
 MODULE_DEVICE_TABLE(of, exynos_ohci_match);
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index 7482cfbe8c5e..88731b7c5f42 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -44,6 +44,7 @@ __acquires(ohci->lock)
         // ASSERT (urb->hcpriv != 0);
 
         urb_free_priv (ohci, urb->hcpriv);
+        urb->hcpriv = NULL;
         if (likely(status == -EINPROGRESS))
                 status = 0;
 
diff --git a/drivers/usb/host/uhci-debug.c b/drivers/usb/host/uhci-debug.c
index fc0b0daac93d..455737546525 100644
--- a/drivers/usb/host/uhci-debug.c
+++ b/drivers/usb/host/uhci-debug.c
@@ -16,6 +16,8 @@
 
 #include "uhci-hcd.h"
 
+#define EXTRA_SPACE     1024
+
 static struct dentry *uhci_debugfs_root;
 
 #ifdef DEBUG
@@ -44,10 +46,6 @@ static int uhci_show_td(struct uhci_hcd *uhci, struct uhci_td *td, char *buf,
         char *spid;
         u32 status, token;
 
-        /* Try to make sure there's enough memory */
-        if (len < 160)
-                return 0;
-
         status = td_status(uhci, td);
         out += sprintf(out, "%*s[%p] link (%08x) ", space, "", td,
                 hc32_to_cpu(uhci, td->link));
@@ -64,6 +62,8 @@ static int uhci_show_td(struct uhci_hcd *uhci, struct uhci_td *td, char *buf,
                 (status & TD_CTRL_CRCTIMEO) ? "CRC/Timeo " : "",
                 (status & TD_CTRL_BITSTUFF) ? "BitStuff " : "",
                 status & 0x7ff);
+        if (out - buf > len)
+                goto done;
 
         token = td_token(uhci, td);
         switch (uhci_packetid(token)) {
@@ -90,6 +90,9 @@ static int uhci_show_td(struct uhci_hcd *uhci, struct uhci_td *td, char *buf,
                 spid);
         out += sprintf(out, "(buf=%08x)\n", hc32_to_cpu(uhci, td->buffer));
 
+done:
+        if (out - buf > len)
+                out += sprintf(out, " ...\n");
         return out - buf;
 }
 
@@ -101,8 +104,6 @@ static int uhci_show_urbp(struct uhci_hcd *uhci, struct urb_priv *urbp,
         int i, nactive, ninactive;
         char *ptype;
 
-        if (len < 200)
-                return 0;
 
         out += sprintf(out, "urb_priv [%p] ", urbp);
         out += sprintf(out, "urb [%p] ", urbp->urb);
@@ -110,6 +111,8 @@ static int uhci_show_urbp(struct uhci_hcd *uhci, struct urb_priv *urbp,
         out += sprintf(out, "Dev=%d ", usb_pipedevice(urbp->urb->pipe));
         out += sprintf(out, "EP=%x(%s) ", usb_pipeendpoint(urbp->urb->pipe),
                         (usb_pipein(urbp->urb->pipe) ? "IN" : "OUT"));
+        if (out - buf > len)
+                goto done;
 
         switch (usb_pipetype(urbp->urb->pipe)) {
         case PIPE_ISOCHRONOUS: ptype = "ISO"; break;
@@ -128,6 +131,9 @@ static int uhci_show_urbp(struct uhci_hcd *uhci, struct urb_priv *urbp,
                 out += sprintf(out, " Unlinked=%d", urbp->urb->unlinked);
         out += sprintf(out, "\n");
 
+        if (out - buf > len)
+                goto done;
+
         i = nactive = ninactive = 0;
         list_for_each_entry(td, &urbp->td_list, list) {
                 if (urbp->qh->type != USB_ENDPOINT_XFER_ISOC &&
@@ -135,6 +141,8 @@ static int uhci_show_urbp(struct uhci_hcd *uhci, struct urb_priv *urbp,
                         out += sprintf(out, "%*s%d: ", space + 2, "", i);
                         out += uhci_show_td(uhci, td, out,
                                         len - (out - buf), 0);
+                        if (out - buf > len)
+                                goto tail;
                 } else {
                         if (td_status(uhci, td) & TD_CTRL_ACTIVE)
                                 ++nactive;
@@ -143,10 +151,13 @@ static int uhci_show_urbp(struct uhci_hcd *uhci, struct urb_priv *urbp,
                 }
         }
         if (nactive + ninactive > 0)
-                out += sprintf(out, "%*s[skipped %d inactive and %d active "
-                                "TDs]\n",
+                out += sprintf(out,
+                                "%*s[skipped %d inactive and %d active TDs]\n",
                                 space, "", ninactive, nactive);
-
+done:
+        if (out - buf > len)
+                out += sprintf(out, " ...\n");
+tail:
         return out - buf;
 }
 
@@ -158,10 +169,6 @@ static int uhci_show_qh(struct uhci_hcd *uhci,
         __hc32 element = qh_element(qh);
         char *qtype;
 
-        /* Try to make sure there's enough memory */
-        if (len < 80 * 7)
-                return 0;
-
         switch (qh->type) {
         case USB_ENDPOINT_XFER_ISOC: qtype = "ISO"; break;
         case USB_ENDPOINT_XFER_INT: qtype = "INT"; break;
@@ -175,13 +182,15 @@ static int uhci_show_qh(struct uhci_hcd *uhci,
                         hc32_to_cpu(uhci, qh->link),
                         hc32_to_cpu(uhci, element));
         if (qh->type == USB_ENDPOINT_XFER_ISOC)
-                out += sprintf(out, "%*s    period %d phase %d load %d us, "
-                                "frame %x desc [%p]\n",
+                out += sprintf(out,
+                                "%*s    period %d phase %d load %d us, frame %x desc [%p]\n",
                                 space, "", qh->period, qh->phase, qh->load,
                                 qh->iso_frame, qh->iso_packet_desc);
         else if (qh->type == USB_ENDPOINT_XFER_INT)
                 out += sprintf(out, "%*s    period %d phase %d load %d us\n",
                                 space, "", qh->period, qh->phase, qh->load);
+        if (out - buf > len)
+                goto done;
 
         if (element & UHCI_PTR_QH(uhci))
                 out += sprintf(out, "%*s  Element points to QH (bug?)\n", space, "");
@@ -195,11 +204,17 @@ static int uhci_show_qh(struct uhci_hcd *uhci,
         if (!(element & ~(UHCI_PTR_QH(uhci) | UHCI_PTR_DEPTH(uhci))))
                 out += sprintf(out, "%*s  Element is NULL (bug?)\n", space, "");
 
+        if (out - buf > len)
+                goto done;
+
         if (list_empty(&qh->queue)) {
                 out += sprintf(out, "%*s  queue is empty\n", space, "");
-                if (qh == uhci->skel_async_qh)
+                if (qh == uhci->skel_async_qh) {
                         out += uhci_show_td(uhci, uhci->term_td, out,
                                         len - (out - buf), 0);
+                        if (out - buf > len)
+                                goto tail;
+                }
         } else {
                 struct urb_priv *urbp = list_entry(qh->queue.next,
                                 struct urb_priv, node);
@@ -211,9 +226,12 @@ static int uhci_show_qh(struct uhci_hcd *uhci,
                                         space, "");
                 i = nurbs = 0;
                 list_for_each_entry(urbp, &qh->queue, node) {
-                        if (++i <= 10)
+                        if (++i <= 10) {
                                 out += uhci_show_urbp(uhci, urbp, out,
                                                 len - (out - buf), space + 2);
+                                if (out - buf > len)
+                                        goto tail;
+                        }
                         else
                                 ++nurbs;
                 }
@@ -222,24 +240,27 @@ static int uhci_show_qh(struct uhci_hcd *uhci,
                                         space, "", nurbs);
         }
 
+        if (out - buf > len)
+                goto done;
+
         if (qh->dummy_td) {
                 out += sprintf(out, "%*s  Dummy TD\n", space, "");
                 out += uhci_show_td(uhci, qh->dummy_td, out,
                                 len - (out - buf), 0);
+                if (out - buf > len)
+                        goto tail;
         }
 
+done:
+        if (out - buf > len)
+                out += sprintf(out, " ...\n");
+tail:
         return out - buf;
 }
 
-static int uhci_show_sc(int port, unsigned short status, char *buf, int len)
+static int uhci_show_sc(int port, unsigned short status, char *buf)
 {
-        char *out = buf;
-
-        /* Try to make sure there's enough memory */
-        if (len < 160)
-                return 0;
-
-        out += sprintf(out, "  stat%d     =     %04x  %s%s%s%s%s%s%s%s%s%s\n",
+        return sprintf(buf, "  stat%d     =     %04x  %s%s%s%s%s%s%s%s%s%s\n",
                 port,
                 status,
                 (status & USBPORTSC_SUSP) ?     " Suspend" : "",
@@ -252,19 +273,12 @@ static int uhci_show_sc(int port, unsigned short status, char *buf, int len)
                 (status & USBPORTSC_PE) ?       " Enabled" : "",
                 (status & USBPORTSC_CSC) ?      " ConnectChange" : "",
                 (status & USBPORTSC_CCS) ?      " Connected" : "");
-
-        return out - buf;
 }
 
-static int uhci_show_root_hub_state(struct uhci_hcd *uhci, char *buf, int len)
+static int uhci_show_root_hub_state(struct uhci_hcd *uhci, char *buf)
 {
-        char *out = buf;
         char *rh_state;
 
-        /* Try to make sure there's enough memory */
-        if (len < 60)
-                return 0;
-
         switch (uhci->rh_state) {
             case UHCI_RH_RESET:
                 rh_state = "reset";             break;
@@ -283,9 +297,8 @@ static int uhci_show_root_hub_state(struct uhci_hcd *uhci, char *buf, int len)
             default:
                 rh_state = "?";                 break;
         }
-        out += sprintf(out, "Root-hub state: %s   FSBR: %d\n",
+        return sprintf(buf, "Root-hub state: %s   FSBR: %d\n",
                         rh_state, uhci->fsbr_is_on);
-        return out - buf;
 }
 
 static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len)
@@ -296,9 +309,6 @@ static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len)
         unsigned char sof;
         unsigned short portsc1, portsc2;
 
-        /* Try to make sure there's enough memory */
-        if (len < 80 * 9)
-                return 0;
 
         usbcmd    = uhci_readw(uhci, 0);
         usbstat   = uhci_readw(uhci, 2);
@@ -319,6 +329,8 @@ static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len)
                 (usbcmd & USBCMD_GRESET) ?  "GRESET " : "",
                 (usbcmd & USBCMD_HCRESET) ? "HCRESET " : "",
                 (usbcmd & USBCMD_RS) ?      "RS " : "");
+        if (out - buf > len)
+                goto done;
 
         out += sprintf(out, "  usbstat   =     %04x   %s%s%s%s%s%s\n",
                 usbstat,
@@ -328,19 +340,33 @@ static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len)
                 (usbstat & USBSTS_RD) ?     "ResumeDetect " : "",
                 (usbstat & USBSTS_ERROR) ?  "USBError " : "",
                 (usbstat & USBSTS_USBINT) ? "USBINT " : "");
+        if (out - buf > len)
+                goto done;
 
         out += sprintf(out, "  usbint    =     %04x\n", usbint);
         out += sprintf(out, "  usbfrnum  =   (%d)%03x\n", (usbfrnum >> 10) & 1,
                 0xfff & (4*(unsigned int)usbfrnum));
         out += sprintf(out, "  flbaseadd = %08x\n", flbaseadd);
         out += sprintf(out, "  sof       =       %02x\n", sof);
-        out += uhci_show_sc(1, portsc1, out, len - (out - buf));
-        out += uhci_show_sc(2, portsc2, out, len - (out - buf));
-        out += sprintf(out, "Most recent frame: %x (%d)   "
-                        "Last ISO frame: %x (%d)\n",
+        if (out - buf > len)
+                goto done;
+
+        out += uhci_show_sc(1, portsc1, out);
+        if (out - buf > len)
+                goto done;
+
+        out += uhci_show_sc(2, portsc2, out);
+        if (out - buf > len)
+                goto done;
+
+        out += sprintf(out,
+                        "Most recent frame: %x (%d)   Last ISO frame: %x (%d)\n",
                         uhci->frame_number, uhci->frame_number & 1023,
                         uhci->last_iso_frame, uhci->last_iso_frame & 1023);
 
+done:
+        if (out - buf > len)
+                out += sprintf(out, " ...\n");
         return out - buf;
 }
 
@@ -360,9 +386,13 @@ static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
                 "int8", "int4", "int2", "async", "term"
         };
 
-        out += uhci_show_root_hub_state(uhci, out, len - (out - buf));
+        out += uhci_show_root_hub_state(uhci, out);
+        if (out - buf > len)
+                goto done;
         out += sprintf(out, "HC status\n");
         out += uhci_show_status(uhci, out, len - (out - buf));
+        if (out - buf > len)
+                goto tail;
 
         out += sprintf(out, "Periodic load table\n");
         for (i = 0; i < MAX_PHASE; ++i) {
@@ -375,7 +405,7 @@ static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
                         uhci_to_hcd(uhci)->self.bandwidth_int_reqs,
                         uhci_to_hcd(uhci)->self.bandwidth_isoc_reqs);
         if (debug <= 1)
-                return out - buf;
+                goto tail;
 
         out += sprintf(out, "Frame List\n");
         nframes = 10;
@@ -383,6 +413,8 @@ static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
         for (i = 0; i < UHCI_NUMFRAMES; ++i) {
                 __hc32 qh_dma;
 
+                if (out - buf > len)
+                        goto done;
                 j = 0;
                 td = uhci->frame_cpu[i];
                 link = uhci->frame[i];
@@ -401,15 +433,20 @@ static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
                         td = list_entry(tmp, struct uhci_td, fl_list);
                         tmp = tmp->next;
                         if (link != LINK_TO_TD(uhci, td)) {
-                                if (nframes > 0)
-                                        out += sprintf(out, "    link does "
-                                                "not match list entry!\n");
-                                else
+                                if (nframes > 0) {
+                                        out += sprintf(out,
+                                                "    link does not match list entry!\n");
+                                        if (out - buf > len)
+                                                goto done;
+                                } else
                                         ++nerrs;
                         }
-                        if (nframes > 0)
+                        if (nframes > 0) {
                                 out += uhci_show_td(uhci, td, out,
                                                 len - (out - buf), 4);
+                                if (out - buf > len)
+                                        goto tail;
+                        }
                         link = td->link;
                 } while (tmp != head);
 
@@ -423,9 +460,11 @@ check_link:
                                                 i, hc32_to_cpu(uhci, link));
                                         j = 1;
                                 }
-                                out += sprintf(out, "   link does not match "
-                                        "QH (%08x)!\n",
+                                out += sprintf(out,
+                                        "   link does not match QH (%08x)!\n",
                                         hc32_to_cpu(uhci, qh_dma));
+                                if (out - buf > len)
+                                        goto done;
                         } else
                                 ++nerrs;
                 }
@@ -436,18 +475,27 @@ check_link:
 
         out += sprintf(out, "Skeleton QHs\n");
 
+        if (out - buf > len)
+                goto done;
+
         fsbr_link = 0;
         for (i = 0; i < UHCI_NUM_SKELQH; ++i) {
                 int cnt = 0;
 
                 qh = uhci->skelqh[i];
-                out += sprintf(out, "- skel_%s_qh\n", qh_names[i]); \
+                out += sprintf(out, "- skel_%s_qh\n", qh_names[i]);
                 out += uhci_show_qh(uhci, qh, out, len - (out - buf), 4);
+                if (out - buf > len)
+                        goto tail;
 
                 /* Last QH is the Terminating QH, it's different */
                 if (i == SKEL_TERM) {
-                        if (qh_element(qh) != LINK_TO_TD(uhci, uhci->term_td))
-                                out += sprintf(out, "    skel_term_qh element is not set to term_td!\n");
+                        if (qh_element(qh) != LINK_TO_TD(uhci, uhci->term_td)) {
+                                out += sprintf(out,
+                                        "    skel_term_qh element is not set to term_td!\n");
+                                if (out - buf > len)
+                                        goto done;
+                        }
                         link = fsbr_link;
                         if (!link)
                                 link = LINK_TO_QH(uhci, uhci->skel_term_qh);
@@ -460,9 +508,12 @@ check_link:
                 while (tmp != head) {
                         qh = list_entry(tmp, struct uhci_qh, node);
                         tmp = tmp->next;
-                        if (++cnt <= 10)
+                        if (++cnt <= 10) {
                                 out += uhci_show_qh(uhci, qh, out,
                                                 len - (out - buf), 4);
+                                if (out - buf > len)
+                                        goto tail;
+                        }
                         if (!fsbr_link && qh->skel >= SKEL_FSBR)
                                 fsbr_link = LINK_TO_QH(uhci, qh);
                 }
@@ -480,9 +531,17 @@ check_link:
                         link = LINK_TO_QH(uhci, uhci->skel_term_qh);
 check_qh_link:
                 if (qh->link != link)
-                        out += sprintf(out, "    last QH not linked to next skeleton!\n");
+                        out += sprintf(out,
+                                "    last QH not linked to next skeleton!\n");
+
+                if (out - buf > len)
+                        goto done;
         }
 
+done:
+        if (out - buf > len)
+                out += sprintf(out, " ...\n");
+tail:
         return out - buf;
 }
 
@@ -514,7 +573,8 @@ static int uhci_debug_open(struct inode *inode, struct file *file)
         up->size = 0;
         spin_lock_irqsave(&uhci->lock, flags);
         if (uhci->is_initialized)
-                up->size = uhci_sprint_schedule(uhci, up->data, MAX_OUTPUT);
+                up->size = uhci_sprint_schedule(uhci, up->data,
+                                        MAX_OUTPUT - EXTRA_SPACE);
         spin_unlock_irqrestore(&uhci->lock, flags);
 
         file->private_data = up;
@@ -529,7 +589,9 @@ static loff_t uhci_debug_lseek(struct file *file, loff_t off, int whence)
 
         up = file->private_data;
 
-        /* XXX: atomic 64bit seek access, but that needs to be fixed in the VFS */
+        /*
+         * XXX: atomic 64bit seek access, but that needs to be fixed in the VFS
+         */
         switch (whence) {
         case 0:
                 new = off;
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index 4f64d24eebc8..4a86b63745b8 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -453,20 +453,19 @@ static irqreturn_t uhci_irq(struct usb_hcd *hcd)
 
         if (status & ~(USBSTS_USBINT | USBSTS_ERROR | USBSTS_RD)) {
                 if (status & USBSTS_HSE)
-                        dev_err(uhci_dev(uhci), "host system error, "
-                                        "PCI problems?\n");
+                        dev_err(uhci_dev(uhci),
+                                "host system error, PCI problems?\n");
                 if (status & USBSTS_HCPE)
-                        dev_err(uhci_dev(uhci), "host controller process "
-                                        "error, something bad happened!\n");
+                        dev_err(uhci_dev(uhci),
+                                "host controller process error, something bad happened!\n");
                 if (status & USBSTS_HCH) {
                         if (uhci->rh_state >= UHCI_RH_RUNNING) {
                                 dev_err(uhci_dev(uhci),
-                                        "host controller halted, "
-                                        "very bad!\n");
+                                        "host controller halted, very bad!\n");
                                 if (debug > 1 && errbuf) {
                                         /* Print the schedule for debugging */
-                                        uhci_sprint_schedule(uhci,
-                                                        errbuf, ERRBUF_LEN);
+                                        uhci_sprint_schedule(uhci, errbuf,
+                                                ERRBUF_LEN - EXTRA_SPACE);
                                         lprintk(errbuf);
                                 }
                                 uhci_hc_died(uhci);
@@ -592,8 +591,8 @@ static int uhci_start(struct usb_hcd *hcd)
                         UHCI_NUMFRAMES * sizeof(*uhci->frame),
                         &uhci->frame_dma_handle, 0);
         if (!uhci->frame) {
-                dev_err(uhci_dev(uhci), "unable to allocate "
-                                "consistent memory for frame list\n");
+                dev_err(uhci_dev(uhci),
+                        "unable to allocate consistent memory for frame list\n");
                 goto err_alloc_frame;
         }
         memset(uhci->frame, 0, UHCI_NUMFRAMES * sizeof(*uhci->frame));
@@ -601,8 +600,8 @@ static int uhci_start(struct usb_hcd *hcd)
         uhci->frame_cpu = kcalloc(UHCI_NUMFRAMES, sizeof(*uhci->frame_cpu),
                         GFP_KERNEL);
         if (!uhci->frame_cpu) {
-                dev_err(uhci_dev(uhci), "unable to allocate "
-                                "memory for frame pointers\n");
+                dev_err(uhci_dev(uhci),
+                        "unable to allocate memory for frame pointers\n");
                 goto err_alloc_frame_cpu;
         }
 
@@ -737,8 +736,8 @@ static int uhci_rh_suspend(struct usb_hcd *hcd)
          */
         else if (hcd->self.root_hub->do_remote_wakeup &&
                         uhci->resuming_ports) {
-                dev_dbg(uhci_dev(uhci), "suspend failed because a port "
-                                "is resuming\n");
+                dev_dbg(uhci_dev(uhci),
+                        "suspend failed because a port is resuming\n");
                 rc = -EBUSY;
         } else
                 suspend_rh(uhci, UHCI_RH_SUSPENDED);
@@ -829,8 +828,8 @@ static int uhci_count_ports(struct usb_hcd *hcd)
 
         /* Anything greater than 7 is weird so we'll ignore it. */
         if (port > UHCI_RH_MAXCHILD) {
-                dev_info(uhci_dev(uhci), "port count misdetected? "
-                                "forcing to 2 ports\n");
+                dev_info(uhci_dev(uhci),
+                        "port count misdetected? forcing to 2 ports\n");
                 port = 2;
         }
 
diff --git a/drivers/usb/host/uhci-hcd.h b/drivers/usb/host/uhci-hcd.h
index 7af2b7052047..6f986d82472d 100644
--- a/drivers/usb/host/uhci-hcd.h
+++ b/drivers/usb/host/uhci-hcd.h
@@ -212,10 +212,6 @@ struct uhci_qh {
 #define TD_CTRL_BITSTUFF        (1 << 17)       /* Bit Stuff Error */
 #define TD_CTRL_ACTLEN_MASK     0x7FF   /* actual length, encoded as n - 1 */
 
-#define TD_CTRL_ANY_ERROR       (TD_CTRL_STALLED | TD_CTRL_DBUFERR | \
-                                 TD_CTRL_BABBLE | TD_CTRL_CRCTIME | \
-                                 TD_CTRL_BITSTUFF)
-
 #define uhci_maxerr(err)                ((err) << TD_CTRL_C_ERR_SHIFT)
 #define uhci_status_bits(ctrl_sts)      ((ctrl_sts) & 0xF60000)
 #define uhci_actual_length(ctrl_sts)    (((ctrl_sts) + 1) & \
diff --git a/drivers/usb/host/uhci-hub.c b/drivers/usb/host/uhci-hub.c
index 15d13229ddbb..f87bee6d2789 100644
--- a/drivers/usb/host/uhci-hub.c
+++ b/drivers/usb/host/uhci-hub.c
@@ -21,8 +21,8 @@ static const __u8 root_hub_hub_des[] =
         0x00,                   /*   (per-port OC, no power switching) */
         0x01,                   /*  __u8  bPwrOn2pwrGood; 2ms */
         0x00,                   /*  __u8  bHubContrCurrent; 0 mA */
-        0x00,                   /*  __u8  DeviceRemovable; *** 7 Ports max *** */
-        0xff                    /*  __u8  PortPwrCtrlMask; *** 7 ports max *** */
+        0x00,                   /*  __u8  DeviceRemovable; *** 7 Ports max */
+        0xff                    /*  __u8  PortPwrCtrlMask; *** 7 ports max */
 };
 
 #define UHCI_RH_MAXCHILD        7
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index 15921fd55048..f0976d8190bc 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -1200,7 +1200,7 @@ static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb)
                                 if (debug > 1 && errbuf) {
                                         /* Print the chain for debugging */
                                         uhci_show_qh(uhci, urbp->qh, errbuf,
-                                                        ERRBUF_LEN, 0);
+                                                ERRBUF_LEN - EXTRA_SPACE, 0);
                                         lprintk(errbuf);
                                 }
                         }
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 7f76a49e90d3..882875465301 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -2708,13 +2708,11 @@ irqreturn_t xhci_irq(struct usb_hcd *hcd)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         u32 status;
-        union xhci_trb *trb;
         u64 temp_64;
         union xhci_trb *event_ring_deq;
         dma_addr_t deq;
 
         spin_lock(&xhci->lock);
-        trb = xhci->event_ring->dequeue;
         /* Check if the xHC generated the interrupt, or the irq is shared */
         status = xhci_readl(xhci, &xhci->op_regs->status);
         if (status == 0xffffffff)