forked from KolibriOS/kolibrios
467 lines
14 KiB
C
467 lines
14 KiB
C
/* i915_irq.c -- IRQ support for the I915 -*- linux-c -*-
|
|
*/
|
|
/*
|
|
* Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
|
|
* All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
* of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
|
* IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
|
|
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
#include <linux/irqreturn.h>
|
|
//#include <linux/slab.h>
|
|
#include "drmP.h"
|
|
#include "drm.h"
|
|
#include "i915_drm.h"
|
|
#include "i915_drv.h"
|
|
#include "i915_trace.h"
|
|
#include "intel_drv.h"
|
|
|
|
#define DRM_WAKEUP( queue ) wake_up( queue )
|
|
#define DRM_INIT_WAITQUEUE( queue ) init_waitqueue_head( queue )
|
|
|
|
#define MAX_NOPID ((u32)~0)
|
|
|
|
/**
|
|
* Interrupts that are always left unmasked.
|
|
*
|
|
* Since pipe events are edge-triggered from the PIPESTAT register to IIR,
|
|
* we leave them always unmasked in IMR and then control enabling them through
|
|
* PIPESTAT alone.
|
|
*/
|
|
#define I915_INTERRUPT_ENABLE_FIX \
|
|
(I915_ASLE_INTERRUPT | \
|
|
I915_DISPLAY_PIPE_A_EVENT_INTERRUPT | \
|
|
I915_DISPLAY_PIPE_B_EVENT_INTERRUPT | \
|
|
I915_DISPLAY_PLANE_A_FLIP_PENDING_INTERRUPT | \
|
|
I915_DISPLAY_PLANE_B_FLIP_PENDING_INTERRUPT | \
|
|
I915_RENDER_COMMAND_PARSER_ERROR_INTERRUPT)
|
|
|
|
/** Interrupts that we mask and unmask at runtime. */
|
|
#define I915_INTERRUPT_ENABLE_VAR (I915_USER_INTERRUPT | I915_BSD_USER_INTERRUPT)
|
|
|
|
#define I915_PIPE_VBLANK_STATUS (PIPE_START_VBLANK_INTERRUPT_STATUS |\
|
|
PIPE_VBLANK_INTERRUPT_STATUS)
|
|
|
|
#define I915_PIPE_VBLANK_ENABLE (PIPE_START_VBLANK_INTERRUPT_ENABLE |\
|
|
PIPE_VBLANK_INTERRUPT_ENABLE)
|
|
|
|
#define DRM_I915_VBLANK_PIPE_ALL (DRM_I915_VBLANK_PIPE_A | \
|
|
DRM_I915_VBLANK_PIPE_B)
|
|
|
|
/* For display hotplug interrupt */
|
|
static void
|
|
ironlake_enable_display_irq(drm_i915_private_t *dev_priv, u32 mask)
|
|
{
|
|
if ((dev_priv->irq_mask & mask) != 0) {
|
|
dev_priv->irq_mask &= ~mask;
|
|
I915_WRITE(DEIMR, dev_priv->irq_mask);
|
|
POSTING_READ(DEIMR);
|
|
}
|
|
}
|
|
|
|
static inline void
|
|
ironlake_disable_display_irq(drm_i915_private_t *dev_priv, u32 mask)
|
|
{
|
|
if ((dev_priv->irq_mask & mask) != mask) {
|
|
dev_priv->irq_mask |= mask;
|
|
I915_WRITE(DEIMR, dev_priv->irq_mask);
|
|
POSTING_READ(DEIMR);
|
|
}
|
|
}
|
|
static void notify_ring(struct drm_device *dev,
|
|
struct intel_ring_buffer *ring)
|
|
{
|
|
struct drm_i915_private *dev_priv = dev->dev_private;
|
|
u32 seqno;
|
|
|
|
if (ring->obj == NULL)
|
|
return;
|
|
|
|
seqno = ring->get_seqno(ring);
|
|
trace_i915_gem_request_complete(ring, seqno);
|
|
|
|
ring->irq_seqno = seqno;
|
|
wake_up_all(&ring->irq_queue);
|
|
// if (i915_enable_hangcheck) {
|
|
// dev_priv->hangcheck_count = 0;
|
|
// mod_timer(&dev_priv->hangcheck_timer,
|
|
// jiffies +
|
|
// msecs_to_jiffies(DRM_I915_HANGCHECK_PERIOD));
|
|
// }
|
|
}
|
|
|
|
|
|
|
|
static int ironlake_irq_handler(struct drm_device *dev)
|
|
{
|
|
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
|
|
int ret = IRQ_NONE;
|
|
u32 de_iir, gt_iir, de_ier, pch_iir, pm_iir;
|
|
u32 hotplug_mask;
|
|
struct drm_i915_master_private *master_priv;
|
|
u32 bsd_usr_interrupt = GT_BSD_USER_INTERRUPT;
|
|
|
|
atomic_inc(&dev_priv->irq_received);
|
|
|
|
if (IS_GEN6(dev))
|
|
bsd_usr_interrupt = GT_GEN6_BSD_USER_INTERRUPT;
|
|
|
|
/* disable master interrupt before clearing iir */
|
|
de_ier = I915_READ(DEIER);
|
|
I915_WRITE(DEIER, de_ier & ~DE_MASTER_IRQ_CONTROL);
|
|
POSTING_READ(DEIER);
|
|
|
|
de_iir = I915_READ(DEIIR);
|
|
gt_iir = I915_READ(GTIIR);
|
|
pch_iir = I915_READ(SDEIIR);
|
|
pm_iir = I915_READ(GEN6_PMIIR);
|
|
|
|
if (de_iir == 0 && gt_iir == 0 && pch_iir == 0 &&
|
|
(!IS_GEN6(dev) || pm_iir == 0))
|
|
goto done;
|
|
|
|
if (HAS_PCH_CPT(dev))
|
|
hotplug_mask = SDE_HOTPLUG_MASK_CPT;
|
|
else
|
|
hotplug_mask = SDE_HOTPLUG_MASK;
|
|
|
|
ret = IRQ_HANDLED;
|
|
|
|
|
|
if (gt_iir & (GT_USER_INTERRUPT | GT_PIPE_NOTIFY))
|
|
notify_ring(dev, &dev_priv->ring[RCS]);
|
|
if (gt_iir & bsd_usr_interrupt)
|
|
notify_ring(dev, &dev_priv->ring[VCS]);
|
|
if (gt_iir & GT_BLT_USER_INTERRUPT)
|
|
notify_ring(dev, &dev_priv->ring[BCS]);
|
|
|
|
// if (de_iir & DE_GSE)
|
|
// intel_opregion_gse_intr(dev);
|
|
|
|
// if (de_iir & DE_PLANEA_FLIP_DONE) {
|
|
// intel_prepare_page_flip(dev, 0);
|
|
// intel_finish_page_flip_plane(dev, 0);
|
|
// }
|
|
|
|
// if (de_iir & DE_PLANEB_FLIP_DONE) {
|
|
// intel_prepare_page_flip(dev, 1);
|
|
// intel_finish_page_flip_plane(dev, 1);
|
|
// }
|
|
|
|
// if (de_iir & DE_PIPEA_VBLANK)
|
|
// drm_handle_vblank(dev, 0);
|
|
|
|
// if (de_iir & DE_PIPEB_VBLANK)
|
|
// drm_handle_vblank(dev, 1);
|
|
|
|
/* check event from PCH */
|
|
// if (de_iir & DE_PCH_EVENT) {
|
|
// if (pch_iir & hotplug_mask)
|
|
// queue_work(dev_priv->wq, &dev_priv->hotplug_work);
|
|
// pch_irq_handler(dev);
|
|
// }
|
|
|
|
// if (de_iir & DE_PCU_EVENT) {
|
|
// I915_WRITE16(MEMINTRSTS, I915_READ(MEMINTRSTS));
|
|
// i915_handle_rps_change(dev);
|
|
// }
|
|
|
|
if (IS_GEN6(dev) && pm_iir & GEN6_PM_DEFERRED_EVENTS) {
|
|
/*
|
|
* IIR bits should never already be set because IMR should
|
|
* prevent an interrupt from being shown in IIR. The warning
|
|
* displays a case where we've unsafely cleared
|
|
* dev_priv->pm_iir. Although missing an interrupt of the same
|
|
* type is not a problem, it displays a problem in the logic.
|
|
*
|
|
* The mask bit in IMR is cleared by rps_work.
|
|
*/
|
|
unsigned long flags;
|
|
spin_lock_irqsave(&dev_priv->rps_lock, flags);
|
|
WARN(dev_priv->pm_iir & pm_iir, "Missed a PM interrupt\n");
|
|
dev_priv->pm_iir |= pm_iir;
|
|
I915_WRITE(GEN6_PMIMR, dev_priv->pm_iir);
|
|
POSTING_READ(GEN6_PMIMR);
|
|
spin_unlock_irqrestore(&dev_priv->rps_lock, flags);
|
|
// queue_work(dev_priv->wq, &dev_priv->rps_work);
|
|
}
|
|
|
|
/* should clear PCH hotplug event before clear CPU irq */
|
|
I915_WRITE(SDEIIR, pch_iir);
|
|
I915_WRITE(GTIIR, gt_iir);
|
|
I915_WRITE(DEIIR, de_iir);
|
|
I915_WRITE(GEN6_PMIIR, pm_iir);
|
|
|
|
done:
|
|
I915_WRITE(DEIER, de_ier);
|
|
POSTING_READ(DEIER);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* drm_dma.h hooks
|
|
*/
|
|
static void ironlake_irq_preinstall(struct drm_device *dev)
|
|
{
|
|
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
|
|
|
|
atomic_set(&dev_priv->irq_received, 0);
|
|
|
|
// INIT_WORK(&dev_priv->hotplug_work, i915_hotplug_work_func);
|
|
// INIT_WORK(&dev_priv->error_work, i915_error_work_func);
|
|
// if (IS_GEN6(dev) || IS_IVYBRIDGE(dev))
|
|
// INIT_WORK(&dev_priv->rps_work, gen6_pm_rps_work);
|
|
|
|
I915_WRITE(HWSTAM, 0xeffe);
|
|
|
|
if (IS_GEN6(dev)) {
|
|
/* Workaround stalls observed on Sandy Bridge GPUs by
|
|
* making the blitter command streamer generate a
|
|
* write to the Hardware Status Page for
|
|
* MI_USER_INTERRUPT. This appears to serialize the
|
|
* previous seqno write out before the interrupt
|
|
* happens.
|
|
*/
|
|
I915_WRITE(GEN6_BLITTER_HWSTAM, ~GEN6_BLITTER_USER_INTERRUPT);
|
|
I915_WRITE(GEN6_BSD_HWSTAM, ~GEN6_BSD_USER_INTERRUPT);
|
|
}
|
|
|
|
/* XXX hotplug from PCH */
|
|
|
|
I915_WRITE(DEIMR, 0xffffffff);
|
|
I915_WRITE(DEIER, 0x0);
|
|
POSTING_READ(DEIER);
|
|
|
|
/* and GT */
|
|
I915_WRITE(GTIMR, 0xffffffff);
|
|
I915_WRITE(GTIER, 0x0);
|
|
POSTING_READ(GTIER);
|
|
|
|
/* south display irq */
|
|
I915_WRITE(SDEIMR, 0xffffffff);
|
|
I915_WRITE(SDEIER, 0x0);
|
|
POSTING_READ(SDEIER);
|
|
}
|
|
|
|
/*
|
|
* Enable digital hotplug on the PCH, and configure the DP short pulse
|
|
* duration to 2ms (which is the minimum in the Display Port spec)
|
|
*
|
|
* This register is the same on all known PCH chips.
|
|
*/
|
|
|
|
static void ironlake_enable_pch_hotplug(struct drm_device *dev)
|
|
{
|
|
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
|
|
u32 hotplug;
|
|
|
|
hotplug = I915_READ(PCH_PORT_HOTPLUG);
|
|
hotplug &= ~(PORTD_PULSE_DURATION_MASK|PORTC_PULSE_DURATION_MASK|PORTB_PULSE_DURATION_MASK);
|
|
hotplug |= PORTD_HOTPLUG_ENABLE | PORTD_PULSE_DURATION_2ms;
|
|
hotplug |= PORTC_HOTPLUG_ENABLE | PORTC_PULSE_DURATION_2ms;
|
|
hotplug |= PORTB_HOTPLUG_ENABLE | PORTB_PULSE_DURATION_2ms;
|
|
I915_WRITE(PCH_PORT_HOTPLUG, hotplug);
|
|
}
|
|
|
|
static int ironlake_irq_postinstall(struct drm_device *dev)
|
|
{
|
|
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
|
|
/* enable kind of interrupts always enabled */
|
|
u32 display_mask = DE_MASTER_IRQ_CONTROL | DE_GSE | DE_PCH_EVENT |
|
|
DE_PLANEA_FLIP_DONE | DE_PLANEB_FLIP_DONE;
|
|
u32 render_irqs;
|
|
u32 hotplug_mask;
|
|
|
|
DRM_INIT_WAITQUEUE(&dev_priv->ring[RCS].irq_queue);
|
|
if (HAS_BSD(dev))
|
|
DRM_INIT_WAITQUEUE(&dev_priv->ring[VCS].irq_queue);
|
|
if (HAS_BLT(dev))
|
|
DRM_INIT_WAITQUEUE(&dev_priv->ring[BCS].irq_queue);
|
|
|
|
dev_priv->vblank_pipe = DRM_I915_VBLANK_PIPE_A | DRM_I915_VBLANK_PIPE_B;
|
|
dev_priv->irq_mask = ~display_mask;
|
|
|
|
/* should always can generate irq */
|
|
I915_WRITE(DEIIR, I915_READ(DEIIR));
|
|
I915_WRITE(DEIMR, dev_priv->irq_mask);
|
|
I915_WRITE(DEIER, display_mask | DE_PIPEA_VBLANK | DE_PIPEB_VBLANK);
|
|
POSTING_READ(DEIER);
|
|
|
|
dev_priv->gt_irq_mask = ~0;
|
|
|
|
I915_WRITE(GTIIR, I915_READ(GTIIR));
|
|
I915_WRITE(GTIMR, dev_priv->gt_irq_mask);
|
|
|
|
if (IS_GEN6(dev))
|
|
render_irqs =
|
|
GT_USER_INTERRUPT |
|
|
GT_GEN6_BSD_USER_INTERRUPT |
|
|
GT_BLT_USER_INTERRUPT;
|
|
else
|
|
render_irqs =
|
|
GT_USER_INTERRUPT |
|
|
GT_PIPE_NOTIFY |
|
|
GT_BSD_USER_INTERRUPT;
|
|
I915_WRITE(GTIER, render_irqs);
|
|
POSTING_READ(GTIER);
|
|
|
|
if (HAS_PCH_CPT(dev)) {
|
|
hotplug_mask = (SDE_CRT_HOTPLUG_CPT |
|
|
SDE_PORTB_HOTPLUG_CPT |
|
|
SDE_PORTC_HOTPLUG_CPT |
|
|
SDE_PORTD_HOTPLUG_CPT);
|
|
} else {
|
|
hotplug_mask = (SDE_CRT_HOTPLUG |
|
|
SDE_PORTB_HOTPLUG |
|
|
SDE_PORTC_HOTPLUG |
|
|
SDE_PORTD_HOTPLUG |
|
|
SDE_AUX_MASK);
|
|
}
|
|
|
|
dev_priv->pch_irq_mask = ~hotplug_mask;
|
|
|
|
I915_WRITE(SDEIIR, I915_READ(SDEIIR));
|
|
I915_WRITE(SDEIMR, dev_priv->pch_irq_mask);
|
|
I915_WRITE(SDEIER, hotplug_mask);
|
|
POSTING_READ(SDEIER);
|
|
|
|
ironlake_enable_pch_hotplug(dev);
|
|
|
|
if (IS_IRONLAKE_M(dev)) {
|
|
/* Clear & enable PCU event interrupts */
|
|
I915_WRITE(DEIIR, DE_PCU_EVENT);
|
|
I915_WRITE(DEIER, I915_READ(DEIER) | DE_PCU_EVENT);
|
|
ironlake_enable_display_irq(dev_priv, DE_PCU_EVENT);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void intel_irq_init(struct drm_device *dev)
|
|
{
|
|
#if 0
|
|
if (IS_IVYBRIDGE(dev)) {
|
|
/* Share pre & uninstall handlers with ILK/SNB */
|
|
dev->driver->irq_handler = ivybridge_irq_handler;
|
|
dev->driver->irq_preinstall = ironlake_irq_preinstall;
|
|
dev->driver->irq_postinstall = ivybridge_irq_postinstall;
|
|
dev->driver->irq_uninstall = ironlake_irq_uninstall;
|
|
dev->driver->enable_vblank = ivybridge_enable_vblank;
|
|
dev->driver->disable_vblank = ivybridge_disable_vblank;
|
|
} else if (HAS_PCH_SPLIT(dev)) {
|
|
dev->driver->irq_handler = ironlake_irq_handler;
|
|
dev->driver->irq_preinstall = ironlake_irq_preinstall;
|
|
dev->driver->irq_postinstall = ironlake_irq_postinstall;
|
|
dev->driver->irq_uninstall = ironlake_irq_uninstall;
|
|
dev->driver->enable_vblank = ironlake_enable_vblank;
|
|
dev->driver->disable_vblank = ironlake_disable_vblank;
|
|
} else {
|
|
dev->driver->irq_preinstall = i915_driver_irq_preinstall;
|
|
dev->driver->irq_postinstall = i915_driver_irq_postinstall;
|
|
dev->driver->irq_uninstall = i915_driver_irq_uninstall;
|
|
dev->driver->irq_handler = i915_driver_irq_handler;
|
|
dev->driver->enable_vblank = i915_enable_vblank;
|
|
dev->driver->disable_vblank = i915_disable_vblank;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
static struct drm_device *irq_device;
|
|
|
|
void irq_handler_kms()
|
|
{
|
|
// printf("%s\n",__FUNCTION__);
|
|
ironlake_irq_handler(irq_device);
|
|
}
|
|
|
|
int drm_irq_install(struct drm_device *dev)
|
|
{
|
|
int irq_line;
|
|
int ret = 0;
|
|
|
|
ENTER();
|
|
|
|
mutex_lock(&dev->struct_mutex);
|
|
|
|
/* Driver must have been initialized */
|
|
if (!dev->dev_private) {
|
|
mutex_unlock(&dev->struct_mutex);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (dev->irq_enabled) {
|
|
mutex_unlock(&dev->struct_mutex);
|
|
return -EBUSY;
|
|
}
|
|
dev->irq_enabled = 1;
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
irq_device = dev;
|
|
irq_line = drm_dev_to_irq(dev);
|
|
|
|
DRM_DEBUG("irq=%d\n", drm_dev_to_irq(dev));
|
|
|
|
ironlake_irq_preinstall(dev);
|
|
|
|
ret = AttachIntHandler(irq_line, irq_handler_kms, 2);
|
|
if (ret == 0) {
|
|
mutex_lock(&dev->struct_mutex);
|
|
dev->irq_enabled = 0;
|
|
mutex_unlock(&dev->struct_mutex);
|
|
return ret;
|
|
}
|
|
|
|
ret = ironlake_irq_postinstall(dev);
|
|
|
|
// if (ret < 0) {
|
|
// mutex_lock(&dev->struct_mutex);
|
|
// dev->irq_enabled = 0;
|
|
// mutex_unlock(&dev->struct_mutex);
|
|
// free_irq(drm_dev_to_irq(dev), dev);
|
|
// }
|
|
|
|
u16_t cmd = PciRead16(dev->pdev->busnr, dev->pdev->devfn, 4);
|
|
|
|
cmd&= ~(1<<10);
|
|
|
|
PciWrite16(dev->pdev->busnr, dev->pdev->devfn, 4, cmd);
|
|
|
|
dbgprintf("PCI_CMD: %04x\n", cmd);
|
|
|
|
DRM_INFO("i915: irq initialized.\n");
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
|
|
|