Merge tag 'drm-intel-next-2012-04-23' of git://people.freedesktop.org/~danvet/drm-intel into drm-core-next

Daniel Vetter writes:

A new drm-intel-next pull. Highlights:
- More gmbus patches from Daniel Kurtz, I think gmbus is now ready, all
 known issues fixed.
- Fencing cleanup and pipelined fencing removal from Chris.
- rc6 residency interface from Ben, useful for powertop.
- Cleanups and code reorg around the ringbuffer code (Ben&me).
- Use hw semaphores in the pageflip code from Ben.
- More vlv stuff from Jesse, unfortunately his vlv cpu is doa, so less
 merged than I've hoped for - we still have the unused function warning :(
- More hsw patches from Eugeni, again, not yet enabled fully.
- intel_pm.c refactoring from Eugeni.
- Ironlake sprite support from Chris.
- And various smaller improvements/fixes all over the place.

Note that this pull request also contains a backmerge of -rc3 to sort out
a few things in -next. I've also had to frob the shortlog a bit to exclude
anything that -rc3 brings in with this pull.

Regression wise we have a few strange bugs going on, but for all of them
closer inspection revealed that they've been pre-existing, just now
slightly more likely to be hit. And for most of them we have a patch
already. Otherwise QA has not reported any regressions, and I'm also not
aware of anything bad happening in 3.4.

* tag 'drm-intel-next-2012-04-23' of git://people.freedesktop.org/~danvet/drm-intel: (420 commits)
  drm/i915: rc6 residency (fix the fix)
  drm/i915/tv: fix open-coded ARRAY_SIZE.
  drm/i915: invalidate render cache on gen2
  drm/i915: Silence the change of LVDS sync polarity
  drm/i915: add generic power management initialization
  drm/i915: move clock gating functionality into intel_pm module
  drm/i915: move emon functionality into intel_pm module
  drm/i915: move drps, rps and rc6-related functions to intel_pm
  drm/i915: fix line breaks in intel_pm
  drm/i915: move watermarks settings into intel_pm module
  drm/i915: move fbc-related functionality into intel_pm module
  drm/i915: Refactor get_fence() to use the common fence writing routine
  drm/i915: Refactor fence clearing to use the common fence writing routine
  drm/i915: Refactor put_fence() to use the common fence writing routine
  drm/i915: Prepare to consolidate fence writing
  drm/i915: Remove the unsightly "optimisation" from flush_fence()
  drm/i915: Simplify fence finding
  drm/i915: Discard the unused obj->last_fenced_ring
  drm/i915: Remove unused ring->setup_seqno
  drm/i915: Remove fence pipelining
  ...

13 files changed, 57 insertions, 38 deletions

diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 057cdda7a489..806cc95317aa 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -347,6 +347,8 @@ static int ehci_reset (struct ehci_hcd *ehci)
         if (ehci->debug)
                 dbgp_external_startup();
 
+        ehci->port_c_suspend = ehci->suspended_ports =
+                        ehci->resuming_ports = 0;
         return retval;
 }
 
@@ -939,6 +941,7 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
                          * like usb_port_resume() does.
                          */
                         ehci->reset_done[i] = jiffies + msecs_to_jiffies(25);
+                        set_bit(i, &ehci->resuming_ports);
                         ehci_dbg (ehci, "port %d remote wakeup\n", i + 1);
                         mod_timer(&hcd->rh_timer, ehci->reset_done[i]);
                 }
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 256fbd42e48c..38fe07623152 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -223,15 +223,10 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
          * remote wakeup, we must fail the suspend.
          */
         if (hcd->self.root_hub->do_remote_wakeup) {
-                port = HCS_N_PORTS(ehci->hcs_params);
-                while (port--) {
-                        if (ehci->reset_done[port] != 0) {
-                                spin_unlock_irq(&ehci->lock);
-                                ehci_dbg(ehci, "suspend failed because "
-                                                "port %d is resuming\n",
-                                                port + 1);
-                                return -EBUSY;
-                        }
+                if (ehci->resuming_ports) {
+                        spin_unlock_irq(&ehci->lock);
+                        ehci_dbg(ehci, "suspend failed because a port is resuming\n");
+                        return -EBUSY;
                 }
         }
 
@@ -554,16 +549,12 @@ static int
 ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
 {
         struct ehci_hcd *ehci = hcd_to_ehci (hcd);
-        u32             temp, status = 0;
+        u32             temp, status;
         u32             mask;
         int             ports, i, retval = 1;
         unsigned long   flags;
         u32             ppcd = 0;
 
-        /* if !USB_SUSPEND, root hub timers won't get shut down ... */
-        if (ehci->rh_state != EHCI_RH_RUNNING)
-                return 0;
-
         /* init status to no-changes */
         buf [0] = 0;
         ports = HCS_N_PORTS (ehci->hcs_params);
@@ -572,6 +563,11 @@ ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
                 retval++;
         }
 
+        /* Inform the core about resumes-in-progress by returning
+         * a non-zero value even if there are no status changes.
+         */
+        status = ehci->resuming_ports;
+
         /* Some boards (mostly VIA?) report bogus overcurrent indications,
          * causing massive log spam unless we completely ignore them.  It
          * may be relevant that VIA VT8235 controllers, where PORT_POWER is
@@ -846,6 +842,7 @@ static int ehci_hub_control (
                                 ehci_writel(ehci,
                                         temp & ~(PORT_RWC_BITS | PORT_RESUME),
                                         status_reg);
+                                clear_bit(wIndex, &ehci->resuming_ports);
                                 retval = handshake(ehci, status_reg,
                                            PORT_RESUME, 0, 2000 /* 2msec */);
                                 if (retval != 0) {
@@ -864,6 +861,7 @@ static int ehci_hub_control (
                                         ehci->reset_done[wIndex])) {
                         status |= USB_PORT_STAT_C_RESET << 16;
                         ehci->reset_done [wIndex] = 0;
+                        clear_bit(wIndex, &ehci->resuming_ports);
 
                         /* force reset to complete */
                         ehci_writel(ehci, temp & ~(PORT_RWC_BITS | PORT_RESET),
@@ -884,8 +882,10 @@ static int ehci_hub_control (
                                         ehci_readl(ehci, status_reg));
                 }
 
-                if (!(temp & (PORT_RESUME|PORT_RESET)))
+                if (!(temp & (PORT_RESUME|PORT_RESET))) {
                         ehci->reset_done[wIndex] = 0;
+                        clear_bit(wIndex, &ehci->resuming_ports);
+                }
 
                 /* transfer dedicated ports to the companion hc */
                 if ((temp & PORT_CONNECT) &&
@@ -920,6 +920,7 @@ static int ehci_hub_control (
                         status |= USB_PORT_STAT_SUSPEND;
                 } else if (test_bit(wIndex, &ehci->suspended_ports)) {
                         clear_bit(wIndex, &ehci->suspended_ports);
+                        clear_bit(wIndex, &ehci->resuming_ports);
                         ehci->reset_done[wIndex] = 0;
                         if (temp & PORT_PE)
                                 set_bit(wIndex, &ehci->port_c_suspend);
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index 3de48a2d7955..73544bd440bd 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -224,6 +224,7 @@ static int tegra_ehci_hub_control(
                 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
                 /* start resume signalling */
                 ehci_writel(ehci, temp | PORT_RESUME, status_reg);
+                set_bit(wIndex-1, &ehci->resuming_ports);
 
                 spin_unlock_irqrestore(&ehci->lock, flags);
                 msleep(20);
@@ -236,6 +237,7 @@ static int tegra_ehci_hub_control(
                         pr_err("%s: timeout waiting for SUSPEND\n", __func__);
 
                 ehci->reset_done[wIndex-1] = 0;
+                clear_bit(wIndex-1, &ehci->resuming_ports);
 
                 tegra->port_resuming = 1;
                 goto done;
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 8f9acbc96fde..2694ed6558d2 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -117,6 +117,8 @@ struct ehci_hcd {			/* one per controller */
                         the change-suspend feature turned on */
         unsigned long           suspended_ports;        /* which ports are
                         suspended */
+        unsigned long           resuming_ports;         /* which ports have
+                        started to resume */
 
         /* per-HC memory pools (could be per-bus, but ...) */
         struct dma_pool         *qh_pool;       /* qh per active urb */
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index 11de5f1be981..32dada8c8b4f 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -825,9 +825,13 @@ static void __devinit quirk_usb_handoff_xhci(struct pci_dev *pdev)
                 }
         }
 
-        /* Disable any BIOS SMIs */
-        writel(XHCI_LEGACY_DISABLE_SMI,
-                        base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET);
+        val = readl(base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET);
+        /* Mask off (turn off) any enabled SMIs */
+        val &= XHCI_LEGACY_DISABLE_SMI;
+        /* Mask all SMI events bits, RW1C */
+        val |= XHCI_LEGACY_SMI_EVENTS;
+        /* Disable any BIOS SMIs and clear all SMI events*/
+        writel(val, base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET);
 
         if (usb_is_intel_switchable_xhci(pdev))
                 usb_enable_xhci_ports(pdev);
diff --git a/drivers/usb/host/uhci-hub.c b/drivers/usb/host/uhci-hub.c
index 045cde4cbc3d..768d54295a20 100644
--- a/drivers/usb/host/uhci-hub.c
+++ b/drivers/usb/host/uhci-hub.c
@@ -196,11 +196,12 @@ static int uhci_hub_status_data(struct usb_hcd *hcd, char *buf)
         status = get_hub_status_data(uhci, buf);
 
         switch (uhci->rh_state) {
-            case UHCI_RH_SUSPENDING:
             case UHCI_RH_SUSPENDED:
                 /* if port change, ask to be resumed */
-                if (status || uhci->resuming_ports)
+                if (status || uhci->resuming_ports) {
+                        status = 1;
                         usb_hcd_resume_root_hub(hcd);
+                }
                 break;
 
             case UHCI_RH_AUTO_STOPPED:
diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
index e9b0f043455d..4b436f5a4171 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -119,7 +119,7 @@ static void xhci_print_command_reg(struct xhci_hcd *xhci)
         xhci_dbg(xhci, "  Event Interrupts %s\n",
                         (temp & CMD_EIE) ? "enabled " : "disabled");
         xhci_dbg(xhci, "  Host System Error Interrupts %s\n",
-                        (temp & CMD_EIE) ? "enabled " : "disabled");
+                        (temp & CMD_HSEIE) ? "enabled " : "disabled");
         xhci_dbg(xhci, "  HC has %sfinished light reset\n",
                         (temp & CMD_LRESET) ? "not " : "");
 }
diff --git a/drivers/usb/host/xhci-ext-caps.h b/drivers/usb/host/xhci-ext-caps.h
index c7f33123d4c0..377f4242dabb 100644
--- a/drivers/usb/host/xhci-ext-caps.h
+++ b/drivers/usb/host/xhci-ext-caps.h
@@ -62,8 +62,9 @@
 /* USB Legacy Support Control and Status Register  - section 7.1.2 */
 /* Add this offset, plus the value of xECP in HCCPARAMS to the base address */
 #define XHCI_LEGACY_CONTROL_OFFSET      (0x04)
-/* bits 1:2, 5:12, and 17:19 need to be preserved; bits 21:28 should be zero */
-#define XHCI_LEGACY_DISABLE_SMI         ((0x3 << 1) + (0xff << 5) + (0x7 << 17))
+/* bits 1:3, 5:12, and 17:19 need to be preserved; bits 21:28 should be zero */
+#define XHCI_LEGACY_DISABLE_SMI         ((0x7 << 1) + (0xff << 5) + (0x7 << 17))
+#define XHCI_LEGACY_SMI_EVENTS          (0x7 << 29)
 
 /* USB 2.0 xHCI 0.96 L1C capability - section 7.2.2.1.3.2 */
 #define XHCI_L1C               (1 << 16)
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index cae4c6f2845a..68eaa908ac8e 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -1796,11 +1796,6 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
         int i;
 
         /* Free the Event Ring Segment Table and the actual Event Ring */
-        if (xhci->ir_set) {
-                xhci_writel(xhci, 0, &xhci->ir_set->erst_size);
-                xhci_write_64(xhci, 0, &xhci->ir_set->erst_base);
-                xhci_write_64(xhci, 0, &xhci->ir_set->erst_dequeue);
-        }
         size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries);
         if (xhci->erst.entries)
                 dma_free_coherent(&pdev->dev, size,
@@ -1812,7 +1807,6 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
         xhci->event_ring = NULL;
         xhci_dbg(xhci, "Freed event ring\n");
 
-        xhci_write_64(xhci, 0, &xhci->op_regs->cmd_ring);
         if (xhci->cmd_ring)
                 xhci_ring_free(xhci, xhci->cmd_ring);
         xhci->cmd_ring = NULL;
@@ -1841,7 +1835,6 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
         xhci->medium_streams_pool = NULL;
         xhci_dbg(xhci, "Freed medium stream array pool\n");
 
-        xhci_write_64(xhci, 0, &xhci->op_regs->dcbaa_ptr);
         if (xhci->dcbaa)
                 dma_free_coherent(&pdev->dev, sizeof(*xhci->dcbaa),
                                 xhci->dcbaa, xhci->dcbaa->dma);
@@ -2459,6 +2452,8 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
 
 fail:
         xhci_warn(xhci, "Couldn't initialize memory\n");
+        xhci_halt(xhci);
+        xhci_reset(xhci);
         xhci_mem_cleanup(xhci);
         return -ENOMEM;
 }
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index ef98b38626fb..7a856a767e77 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -95,6 +95,8 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                 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;
 }
 
 /* called during probe() after chip reset completes */
@@ -326,7 +328,7 @@ int __init xhci_register_pci(void)
         return pci_register_driver(&xhci_pci_driver);
 }
 
-void __exit xhci_unregister_pci(void)
+void xhci_unregister_pci(void)
 {
         pci_unregister_driver(&xhci_pci_driver);
 }
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 6bd9d53062eb..3d9422f16a20 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -2417,7 +2417,7 @@ hw_died:
                 u32 irq_pending;
                 /* Acknowledge the PCI interrupt */
                 irq_pending = xhci_readl(xhci, &xhci->ir_set->irq_pending);
-                irq_pending |= 0x3;
+                irq_pending |= IMAN_IP;
                 xhci_writel(xhci, irq_pending, &xhci->ir_set->irq_pending);
         }
 
@@ -2734,7 +2734,7 @@ int xhci_queue_intr_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                                 urb->dev->speed == USB_SPEED_FULL)
                         urb->interval /= 8;
         }
-        return xhci_queue_bulk_tx(xhci, GFP_ATOMIC, urb, slot_id, ep_index);
+        return xhci_queue_bulk_tx(xhci, mem_flags, urb, slot_id, ep_index);
 }
 
 /*
@@ -3514,7 +3514,7 @@ int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
         }
         ep_ring->num_trbs_free_temp = ep_ring->num_trbs_free;
 
-        return xhci_queue_isoc_tx(xhci, GFP_ATOMIC, urb, slot_id, ep_index);
+        return xhci_queue_isoc_tx(xhci, mem_flags, urb, slot_id, ep_index);
 }
 
 /****           Command Ring Operations         ****/
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index e1963d4a430f..36641a7f2371 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -106,6 +106,9 @@ int xhci_halt(struct xhci_hcd *xhci)
                         STS_HALT, STS_HALT, XHCI_MAX_HALT_USEC);
         if (!ret)
                 xhci->xhc_state |= XHCI_STATE_HALTED;
+        else
+                xhci_warn(xhci, "Host not halted after %u microseconds.\n",
+                                XHCI_MAX_HALT_USEC);
         return ret;
 }
 
@@ -664,11 +667,11 @@ static void xhci_save_registers(struct xhci_hcd *xhci)
         xhci->s3.dev_nt = xhci_readl(xhci, &xhci->op_regs->dev_notification);
         xhci->s3.dcbaa_ptr = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr);
         xhci->s3.config_reg = xhci_readl(xhci, &xhci->op_regs->config_reg);
-        xhci->s3.irq_pending = xhci_readl(xhci, &xhci->ir_set->irq_pending);
-        xhci->s3.irq_control = xhci_readl(xhci, &xhci->ir_set->irq_control);
         xhci->s3.erst_size = xhci_readl(xhci, &xhci->ir_set->erst_size);
         xhci->s3.erst_base = xhci_read_64(xhci, &xhci->ir_set->erst_base);
         xhci->s3.erst_dequeue = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
+        xhci->s3.irq_pending = xhci_readl(xhci, &xhci->ir_set->irq_pending);
+        xhci->s3.irq_control = xhci_readl(xhci, &xhci->ir_set->irq_control);
 }
 
 static void xhci_restore_registers(struct xhci_hcd *xhci)
@@ -677,10 +680,11 @@ static void xhci_restore_registers(struct xhci_hcd *xhci)
         xhci_writel(xhci, xhci->s3.dev_nt, &xhci->op_regs->dev_notification);
         xhci_write_64(xhci, xhci->s3.dcbaa_ptr, &xhci->op_regs->dcbaa_ptr);
         xhci_writel(xhci, xhci->s3.config_reg, &xhci->op_regs->config_reg);
-        xhci_writel(xhci, xhci->s3.irq_pending, &xhci->ir_set->irq_pending);
-        xhci_writel(xhci, xhci->s3.irq_control, &xhci->ir_set->irq_control);
         xhci_writel(xhci, xhci->s3.erst_size, &xhci->ir_set->erst_size);
         xhci_write_64(xhci, xhci->s3.erst_base, &xhci->ir_set->erst_base);
+        xhci_write_64(xhci, xhci->s3.erst_dequeue, &xhci->ir_set->erst_dequeue);
+        xhci_writel(xhci, xhci->s3.irq_pending, &xhci->ir_set->irq_pending);
+        xhci_writel(xhci, xhci->s3.irq_control, &xhci->ir_set->irq_control);
 }
 
 static void xhci_set_cmd_ring_deq(struct xhci_hcd *xhci)
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 91074fdab3eb..3d69c4b2b542 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -205,6 +205,10 @@ struct xhci_op_regs {
 #define CMD_PM_INDEX    (1 << 11)
 /* bits 12:31 are reserved (and should be preserved on writes). */
 
+/* IMAN - Interrupt Management Register */
+#define IMAN_IP         (1 << 1)
+#define IMAN_IE         (1 << 0)
+
 /* USBSTS - USB status - status bitmasks */
 /* HC not running - set to 1 when run/stop bit is cleared. */
 #define STS_HALT        XHCI_STS_HALT