geemili
/
drm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update vblank code: 

- move pre/post modeset ioctl to core
  - fixup i915 buffer swap
  - fix outstanding signal count code
  - create new core vblank init routine
  - test (works with glxgears)
  - simplify i915 interrupt handler
main
Jesse Barnes 2007-06-12 13:35:41 -07:00
parent db689c7b95
commit ca47fa90b7
8 changed files with 209 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
linux-core/drmP.h
View File

@ -648,7 +648,7 @@ struct drm_driver {
/* these have to be filled in */
irqreturn_t(*irq_handler) (DRM_IRQ_ARGS);
void (*irq_preinstall) (struct drm_device * dev);
void (*irq_postinstall) (struct drm_device * dev);
int (*irq_postinstall) (struct drm_device * dev);
void (*irq_uninstall) (struct drm_device * dev);
void (*reclaim_buffers) (struct drm_device *dev, struct file * filp);
void (*reclaim_buffers_locked) (struct drm_device *dev,
@ -786,10 +786,14 @@ typedef struct drm_device {
wait_queue_head_t vbl_queue; /**< VBLANK wait queue */
atomic_t *vblank_count; /**< number of VBLANK interrupts (driver must alloc the right number of counters) */
spinlock_t vbl_lock;
struct list_head vbl_sigs; /**< signal list to send on VBLANK */
struct list_head vbl_sigs2; /**< signals to send on secondary VBLANK */
atomic_t *vbl_pending;
u32 *last_vblank; /* protected by dev->vbl_lock */
struct list_head *vbl_sigs; /**< signal list to send on VBLANK */
atomic_t vbl_pending; /* number of signals pending on all crtcs*/
atomic_t *vblank_usage; /* number of users of vblank interrupts per crtc */
u32 *last_vblank; /* protected by dev->vbl_lock, used */
/* for wraparound handling */
u32 *vblank_offset; /* used to track how many vblanks */
u32 *vblank_premodeset; /* were lost during modeset */
unsigned long max_vblank_count; /**< size of vblank counter register */
spinlock_t tasklet_lock; /**< For drm_locked_tasklet */
void (*locked_tasklet_func)(struct drm_device *dev);
@ -810,6 +814,7 @@ typedef struct drm_device {
#ifdef __alpha__
struct pci_controller *hose;
#endif
int num_crtcs; /**< Number of CRTCs on this device */
drm_sg_mem_t *sg; /**< Scatter gather memory */
void *dev_private; /**< device private data */
drm_sigdata_t sigdata; /**< For block_all_signals */
@ -1074,11 +1079,18 @@ extern void drm_driver_irq_preinstall(drm_device_t * dev);
extern void drm_driver_irq_postinstall(drm_device_t * dev);
extern void drm_driver_irq_uninstall(drm_device_t * dev);
extern int drm_vblank_init(drm_device_t *dev, int num_crtcs);
extern int drm_wait_vblank(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg);
extern int drm_vblank_wait(drm_device_t * dev, unsigned int *vbl_seq);
extern void drm_vbl_send_signals(drm_device_t * dev);
extern void drm_locked_tasklet(drm_device_t *dev, void(*func)(drm_device_t*));
extern void drm_vblank_get(drm_device_t *dev, int crtc);
extern void drm_vblank_put(drm_device_t *dev, int crtc);
/* Modesetting support */
extern int drm_modeset_ctl(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg);
/* AGP/GART support (drm_agpsupport.h) */
extern drm_agp_head_t *drm_agp_init(drm_device_t *dev);

1
linux-core/drm_drv.c
View File

@ -123,6 +123,7 @@ static drm_ioctl_desc_t drm_ioctls[] = {
DRM_AUTH },
[DRM_IOCTL_NR(DRM_IOCTL_UPDATE_DRAW)] = {drm_update_drawable_info, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
[DRM_IOCTL_NR(DRM_IOCTL_MODESET_CTL)] = {drm_modeset_ctl, 0},
};
#define DRM_CORE_IOCTL_COUNT ARRAY_SIZE( drm_ioctls )

145
linux-core/drm_irq.c
View File

@ -77,6 +77,70 @@ int drm_irq_by_busid(struct inode *inode, struct file *filp,
return 0;
}
int drm_vblank_init(drm_device_t *dev, int num_crtcs)
{
int i, ret = -ENOMEM;
init_waitqueue_head(&dev->vbl_queue);
spin_lock_init(&dev->vbl_lock);
atomic_set(&dev->vbl_pending, 0);
dev->num_crtcs = num_crtcs;
dev->vbl_sigs = drm_alloc(sizeof(struct list_head) * num_crtcs,
DRM_MEM_DRIVER);
if (!dev->vbl_sigs)
goto err;
dev->vblank_count = drm_alloc(sizeof(atomic_t) * num_crtcs,
DRM_MEM_DRIVER);
if (!dev->vblank_count)
goto err;
dev->vblank_usage = drm_alloc(sizeof(atomic_t) * num_crtcs,
DRM_MEM_DRIVER);
if (!dev->vblank_count)
goto err;
dev->last_vblank = drm_alloc(sizeof(u32) * num_crtcs,
DRM_MEM_DRIVER);
if (!dev->last_vblank)
goto err;
dev->vblank_premodeset = drm_alloc(sizeof(u32) * num_crtcs,
DRM_MEM_DRIVER);
if (!dev->vblank_premodeset)
goto err;
dev->vblank_offset = drm_alloc(sizeof(u32) * num_crtcs,
DRM_MEM_DRIVER);
if (!dev->vblank_offset)
goto err;
/* Zero per-crtc vblank stuff */
for (i = 0; i < num_crtcs; i++) {
INIT_LIST_HEAD(&dev->vbl_sigs[i]);
atomic_set(&dev->vblank_count[i], 0);
atomic_set(&dev->vblank_usage[i], 0);
dev->last_vblank[i] = 0;
dev->vblank_premodeset[i] = 0;
dev->vblank_offset[i] = 0;
}
ret = 0;
goto out;
err:
kfree(dev->vbl_sigs);
kfree(dev->vblank_count);
kfree(dev->vblank_usage);
kfree(dev->last_vblank);
kfree(dev->vblank_premodeset);
kfree(dev->vblank_offset);
out:
return ret;
}
EXPORT_SYMBOL(drm_vblank_init);
/**
* Install IRQ handler.
*
@ -88,7 +152,7 @@ int drm_irq_by_busid(struct inode *inode, struct file *filp,
*/
static int drm_irq_install(drm_device_t * dev)
{
int ret;
int ret = 0;
unsigned long sh_flags = 0;
if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
@ -114,17 +178,6 @@ static int drm_irq_install(drm_device_t * dev)
DRM_DEBUG("%s: irq=%d\n", __FUNCTION__, dev->irq);
if (drm_core_check_feature(dev, DRIVER_IRQ_VBL)) {
init_waitqueue_head(&dev->vbl_queue);
spin_lock_init(&dev->vbl_lock);
INIT_LIST_HEAD(&dev->vbl_sigs);
INIT_LIST_HEAD(&dev->vbl_sigs2);
dev->vbl_pending = 0;
}
/* Before installing handler */
dev->driver->irq_preinstall(dev);
@ -142,9 +195,9 @@ static int drm_irq_install(drm_device_t * dev)
}
/* After installing handler */
dev->driver->irq_postinstall(dev);
ret = dev->driver->irq_postinstall(dev);
return 0;
return ret;
}
/**
@ -221,12 +274,12 @@ int drm_control(struct inode *inode, struct file *filp,
}
}
static void drm_vblank_get(drm_device_t *dev, int crtc)
void drm_vblank_get(drm_device_t *dev, int crtc)
{
unsigned long irqflags;
u32 cur_vblank, diff;
if (atomic_add_return(1, &dev->vbl_pending[crtc]) != 1)
if (atomic_add_return(1, &dev->vblank_count[crtc]) != 1)
return;
/*
@ -243,21 +296,60 @@ static void drm_vblank_get(drm_device_t *dev, int crtc)
dev->last_vblank[crtc];
diff += cur_vblank;
} else {
diff = cur_vblank - last_vblank;
diff = cur_vblank - dev->last_vblank[crtc];
}
dev->last_vblank[crtc] = cur_vblank;
spin_lock_irqrestore(&dev->vbl_lock, irqflags);
spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
atomic_add(diff, &dev->vblank_count[crtc]);
dev->driver->enable_vblank(dev, crtc);
}
EXPORT_SYMBOL(drm_vblank_get);
static void drm_vblank_put(drm_device_t *dev, int crtc)
void drm_vblank_put(drm_device_t *dev, int crtc)
{
if (atomic_dec_and_test(&dev->vbl_pending[crtc]))
if (atomic_dec_and_test(&dev->vblank_count[crtc]))
dev->driver->disable_vblank(dev, crtc);
}
EXPORT_SYMBOL(drm_vblank_put);
int drm_modeset_ctl(DRM_IOCTL_ARGS)
{
drm_file_t *priv = filp->private_data;
drm_device_t *dev = priv->head->dev;
drm_modeset_ctl_t __user *argp = (void __user *)data;
drm_modeset_ctl_t modeset;
int crtc, ret = 0;
u32 new;
if (copy_from_user(&modeset, argp, sizeof(modeset))) {
ret = -EFAULT;
goto out;
}
crtc = modeset.arg;
if (crtc > dev->num_crtcs) {
ret = -EINVAL;
goto out;
}
switch (modeset.cmd) {
case _DRM_PRE_MODESET:
dev->vblank_premodeset[crtc] =
dev->driver->get_vblank_counter(dev, crtc);
break;
case _DRM_POST_MODESET:
new = dev->driver->get_vblank_counter(dev, crtc);
dev->vblank_offset[crtc] = dev->vblank_premodeset[crtc] - new;
break;
default:
ret = -EINVAL;
break;
}
out:
return ret;
}
/**
* Wait for VBLANK.
@ -329,8 +421,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
if (flags & _DRM_VBLANK_SIGNAL) {
unsigned long irqflags;
struct list_head *vbl_sigs = (flags & _DRM_VBLANK_SECONDARY)
? &dev->vbl_sigs2 : &dev->vbl_sigs;
struct list_head *vbl_sigs = &dev->vbl_sigs[crtc];
drm_vbl_sig_t *vbl_sig;
spin_lock_irqsave(&dev->vbl_lock, irqflags);
@ -351,7 +442,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
}
}
if (atomic_read(&dev->vbl_pending[crtc]) >= 100) {
if (atomic_read(&dev->vbl_pending) >= 100) {
spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
drm_vblank_put(dev, crtc);
return -EBUSY;
@ -359,6 +450,8 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
atomic_inc(&dev->vbl_pending);
if (!
(vbl_sig =
drm_alloc(sizeof(drm_vbl_sig_t), DRM_MEM_DRIVER))) {
@ -414,9 +507,9 @@ void drm_vbl_send_signals(drm_device_t * dev)
spin_lock_irqsave(&dev->vbl_lock, flags);
for (i = 0; i < 2; i++) {
for (i = 0; i < dev->num_crtcs; i++) {
drm_vbl_sig_t *vbl_sig, *tmp;
struct list_head *vbl_sigs = i ? &dev->vbl_sigs2 : &dev->vbl_sigs;
struct list_head *vbl_sigs = &dev->vbl_sigs[i];
unsigned int vbl_seq = atomic_read(&dev->vblank_count[i]);
list_for_each_entry_safe(vbl_sig, tmp, vbl_sigs, head) {
@ -429,7 +522,7 @@ void drm_vbl_send_signals(drm_device_t * dev)
drm_free(vbl_sig, sizeof(*vbl_sig),
DRM_MEM_DRIVER);
atomic_dec(&dev->vbl_pending);
drm_vblank_put(dev, i);
}
}

17
shared-core/drm.h
View File

@ -587,6 +587,21 @@ typedef union drm_wait_vblank {
struct drm_wait_vblank_reply reply;
} drm_wait_vblank_t;
typedef enum {
_DRM_PRE_MODESET = 1,
_DRM_POST_MODESET = 2,
} drm_modeset_ctl_cmd_t;
/**
* DRM_IOCTL_MODESET_CTL ioctl argument type
*
* \sa drmModesetCtl().
*/
typedef struct drm_modeset_ctl {
drm_modeset_ctl_cmd_t cmd;
unsigned long arg;
} drm_modeset_ctl_t;
/**
* DRM_IOCTL_AGP_ENABLE ioctl argument type.
*
@ -953,6 +968,8 @@ typedef union drm_mm_init_arg{
#define DRM_IOCTL_UPDATE_DRAW DRM_IOW(0x3f, drm_update_draw_t)
#define DRM_IOCTL_MODESET_CTL DRM_IOW(0x40, drm_modeset_ctl_t)
/*@}*/
/**

14
shared-core/i915_dma.c
View File

@ -833,20 +833,6 @@ static int i915_setparam(DRM_IOCTL_ARGS)
case I915_SETPARAM_ALLOW_BATCHBUFFER:
dev_priv->allow_batchbuffer = param.value;
break;
case I915_SETPARAM_PREMODESET:
if (param.value > 1) {
DRM_ERROR("bad crtc\n");
return -EINVAL;
}
i915_premodeset(dev, param.value);
break;
case I915_SETPARAM_POSTMODESET:
if (param.value > 1) {
DRM_ERROR("bad crtc\n");
return -EINVAL;
}
i915_postmodeset(dev, param.value);
break;
default:
DRM_ERROR("unknown parameter %d\n", param.param);
return DRM_ERR(EINVAL);

2
shared-core/i915_drm.h
View File

@ -235,8 +235,6 @@ typedef struct drm_i915_getparam {
#define I915_SETPARAM_USE_MI_BATCHBUFFER_START 1
#define I915_SETPARAM_TEX_LRU_LOG_GRANULARITY 2
#define I915_SETPARAM_ALLOW_BATCHBUFFER 3
#define I915_SETPARAM_PREMODESET 4
#define I915_SETPARAM_POSTMODESET 5
typedef struct drm_i915_setparam {
int param;

6
shared-core/i915_drv.h
View File

@ -132,8 +132,6 @@ typedef struct drm_i915_private {
spinlock_t swaps_lock;
drm_i915_vbl_swap_t vbl_swaps;
unsigned int swaps_pending;
unsigned long vblank_offset[2];
unsigned long vblank_premodeset[2];
} drm_i915_private_t;
enum intel_chip_family {
@ -165,7 +163,7 @@ extern int i915_irq_wait(DRM_IOCTL_ARGS);
extern irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS);
extern void i915_driver_irq_preinstall(drm_device_t * dev);
extern void i915_driver_irq_postinstall(drm_device_t * dev);
extern int i915_driver_irq_postinstall(drm_device_t * dev);
extern void i915_driver_irq_uninstall(drm_device_t * dev);
extern int i915_vblank_pipe_set(DRM_IOCTL_ARGS);
extern int i915_vblank_pipe_get(DRM_IOCTL_ARGS);
@ -176,8 +174,6 @@ extern int i915_vblank_swap(DRM_IOCTL_ARGS);
extern void i915_enable_vblank(drm_device_t *dev, int crtc);
extern void i915_disable_vblank(drm_device_t *dev, int crtc);
extern u32 i915_get_vblank_counter(drm_device_t *dev, int crtc);
extern void i915_premodeset(drm_device_t *dev, int crtc);
extern void i915_postmodeset(drm_device_t *dev, int crtc);
/* i915_mem.c */
extern int i915_mem_alloc(DRM_IOCTL_ARGS);

143
shared-core/i915_irq.c
View File

@ -117,12 +117,14 @@ static void i915_vblank_tasklet(drm_device_t *dev)
list_for_each_safe(list, tmp, &dev_priv->vbl_swaps.head) {
drm_i915_vbl_swap_t *vbl_swap =
list_entry(list, drm_i915_vbl_swap_t, head);
int crtc = vbl_swap->pipe;
if ((counter[vbl_swap->pipe] - vbl_swap->sequence) > (1<<23))
continue;
list_del(list);
dev_priv->swaps_pending--;
drm_vblank_put(dev, crtc);
spin_unlock(&dev_priv->swaps_lock);
spin_lock(&dev->drw_lock);
@ -274,6 +276,32 @@ static void i915_vblank_tasklet(drm_device_t *dev)
}
}
u32 i915_get_vblank_counter(drm_device_t *dev, int crtc)
{
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
unsigned long high_frame = crtc ? PIPEBFRAMEHIGH : PIPEAFRAMEHIGH;
unsigned long low_frame = crtc ? PIPEBFRAMEPIXEL : PIPEAFRAMEPIXEL;
u32 high1, high2, low, count;
/*
* High & low register fields aren't synchronized, so make sure
* we get a low value that's stable across two reads of the high
* register.
*/
do {
high1 = ((I915_READ(high_frame) & PIPE_FRAME_HIGH_MASK) >>
PIPE_FRAME_HIGH_SHIFT);
low = ((I915_READ(low_frame) & PIPE_FRAME_LOW_MASK) >>
PIPE_FRAME_LOW_SHIFT);
high2 = ((I915_READ(high_frame) & PIPE_FRAME_HIGH_MASK) >>
PIPE_FRAME_HIGH_SHIFT);
} while (high1 != high2);
count = (high1 << 8) | low;
return count;
}
irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
{
drm_device_t *dev = (drm_device_t *) arg;
@ -306,22 +334,14 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
#endif
}
if (temp & VSYNC_PIPEA_FLAG)
atomic_add(i915_get_vblank_counter(dev, 0),
&dev->vblank_count[0]);
if (temp & VSYNC_PIPEB_FLAG)
atomic_add(i915_get_vblank_counter(dev, 1),
&dev->vblank_count[1]);
if (temp & (VSYNC_PIPEA_FLAG | VSYNC_PIPEB_FLAG)) {
int vblank_pipe = dev_priv->vblank_pipe;
if ((vblank_pipe &
(DRM_I915_VBLANK_PIPE_A | DRM_I915_VBLANK_PIPE_B))
== (DRM_I915_VBLANK_PIPE_A | DRM_I915_VBLANK_PIPE_B)) {
if (temp & VSYNC_PIPEA_FLAG)
atomic_inc(&dev->vblank_count[0]);
if (temp & VSYNC_PIPEB_FLAG)
atomic_inc(&dev->vblank_count[1]);
} else if (((temp & VSYNC_PIPEA_FLAG) &&
(vblank_pipe & DRM_I915_VBLANK_PIPE_A)) ||
((temp & VSYNC_PIPEB_FLAG) &&
(vblank_pipe & DRM_I915_VBLANK_PIPE_B)))
atomic_inc(&dev->vblank_count[0]);
DRM_WAKEUP(&dev->vbl_queue);
drm_vbl_send_signals(dev);
@ -461,6 +481,9 @@ int i915_irq_wait(DRM_IOCTL_ARGS)
void i915_enable_vblank(drm_device_t *dev, int crtc)
{
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
if (crtc > dev_priv->vblank_pipe)
return;
switch (crtc) {
case 0:
@ -481,6 +504,9 @@ void i915_enable_vblank(drm_device_t *dev, int crtc)
void i915_disable_vblank(drm_device_t *dev, int crtc)
{
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
if (crtc > dev_priv->vblank_pipe)
return;
switch (crtc) {
case 0:
@ -498,54 +524,6 @@ void i915_disable_vblank(drm_device_t *dev, int crtc)
I915_WRITE16(I915REG_INT_ENABLE_R, dev_priv->irq_enable_reg);
}
static u32 i915_vblank_counter(drm_device_t *dev, int crtc)
{
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
unsigned long high_frame = crtc ? PIPEBFRAMEHIGH : PIPEAFRAMEHIGH;
unsigned long low_frame = crtc ? PIPEBFRAMEPIXEL : PIPEAFRAMEPIXEL;
u32 high1, high2, low, count;
/*
* High & low register fields aren't synchronized, so make sure
* we get a low value that's stable across two reads of the high
* register.
*/
do {
high1 = ((I915_READ(high_frame) & PIPE_FRAME_HIGH_MASK) >>
PIPE_FRAME_HIGH_SHIFT);
low = ((I915_READ(low_frame) & PIPE_FRAME_LOW_MASK) >>
PIPE_FRAME_LOW_SHIFT);
high2 = ((I915_READ(high_frame) & PIPE_FRAME_HIGH_MASK) >>
PIPE_FRAME_HIGH_SHIFT);
} while (high1 != high2);
count = (high1 << 8) | low;
return count;
}
u32 i915_get_vblank_counter(drm_device_t *dev, int crtc)
{
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
return i915_vblank_counter(dev, crtc) + dev_priv->vblank_offset[crtc];
}
void i915_premodeset(drm_device_t *dev, int crtc)
{
drm_i915_private_t *dev_priv = dev->dev_private;
dev_priv->vblank_premodeset[crtc] = i915_vblank_counter(dev, crtc);
}
void i915_postmodeset(drm_device_t *dev, int crtc)
{
drm_i915_private_t *dev_priv = dev->dev_private;
u32 new;
new = i915_vblank_counter(dev, crtc);
dev_priv->vblank_offset[crtc] = dev_priv->vblank_premodeset[crtc] - new;
}
static void i915_enable_interrupt (drm_device_t *dev)
{
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
@ -660,6 +638,7 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
drm_vblank_get(dev, pipe);
curseq = atomic_read(&dev->vblank_count[pipe]);
if (seqtype == _DRM_VBLANK_RELATIVE)
@ -670,6 +649,7 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
swap.sequence = curseq + 1;
} else {
DRM_DEBUG("Missed target sequence\n");
drm_vblank_put(dev, pipe);
return DRM_ERR(EINVAL);
}
}
@ -690,6 +670,7 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
DRM_DEBUG("Invalid drawable ID %d\n",
swap.drawable);
drm_vblank_put(dev, pipe);
return DRM_ERR(EINVAL);
}
@ -697,6 +678,7 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
drm_vblank_put(dev, pipe);
return 0;
}
}
@ -712,6 +694,7 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
vbl_swap->flip = (swap.seqtype & _DRM_VBLANK_FLIP);
spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
DRM_DEBUG("Already scheduled\n");
drm_vblank_put(dev, pipe);
return 0;
}
}
@ -720,6 +703,7 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
if (dev_priv->swaps_pending >= 100) {
DRM_DEBUG("Too many swaps queued\n");
drm_vblank_put(dev, pipe);
return DRM_ERR(EBUSY);
}
@ -727,6 +711,7 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
if (!vbl_swap) {
DRM_ERROR("Failed to allocate memory to queue swap\n");
drm_vblank_put(dev, pipe);
return DRM_ERR(ENOMEM);
}
@ -764,10 +749,10 @@ void i915_driver_irq_preinstall(drm_device_t * dev)
I915_WRITE16(I915REG_INT_ENABLE_R, 0x0);
}
void i915_driver_irq_postinstall(drm_device_t * dev)
int i915_driver_irq_postinstall(drm_device_t * dev)
{
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
int i;
int ret, num_pipes = 2;
spin_lock_init(&dev_priv->swaps_lock);
INIT_LIST_HEAD(&dev_priv->vbl_swaps.head);
@ -776,31 +761,10 @@ void i915_driver_irq_postinstall(drm_device_t * dev)
dev_priv->user_irq_lock = SPIN_LOCK_UNLOCKED;
dev_priv->user_irq_refcount = 0;
dev_priv->irq_enable_reg = 0;
dev->vblank_count = kmalloc(sizeof(atomic_t) * 2, GFP_KERNEL);
if (!dev->vblank_count) {
DRM_ERROR("out of memory\n");
return;
}
dev->vbl_pending = kmalloc(sizeof(atomic_t) * 2, GFP_KERNEL);
if (!dev->vbl_pending) {
DRM_ERROR("out of memory\n");
kfree(dev->vblank_count);
return;
}
dev->last_vblank = kmalloc(sizeof(atomic_t) * 2, GFP_KERNEL);
if (!dev->last_vblank) {
DRM_ERROR("out of memory\n");
kfree(dev->vblank_count);
return;
}
/* Zero per-crtc vblank stuff */
for (i = 0; i < 2; i++) {
atomic_set(&dev->vbl_pending[i], 0);
atomic_set(&dev->vblank_count[i], 0);
dev->last_vblank[i] = 0;
dev_priv->vblank_offset[i] = 0;
}
ret = drm_vblank_init(dev, num_pipes);
if (ret)
return ret;
dev->max_vblank_count = 0xffffff; /* only 24 bits of frame count */
@ -812,6 +776,7 @@ void i915_driver_irq_postinstall(drm_device_t * dev)
*/
I915_WRITE(I915REG_INSTPM, ( 1 << 5) | ( 1 << 21));
return 0;
}
void i915_driver_irq_uninstall(drm_device_t * dev)