Menu
▾
▴
drm: Branch 'drm-ttm-0-2-branch' - 26 commits
|
From: <da...@ke...> - 2006-09-29 11:00:14
|
bsd-core/drm_drawable.c | 52 -------
libdrm/xf86drm.c | 16 ++
libdrm/xf86drm.h | 5
linux-core/Makefile | 4
linux-core/drmP.h | 19 ++
linux-core/drm_core.h | 8 -
linux-core/drm_drawable.c | 57 -------
linux-core/drm_drv.c | 16 ++
linux-core/drm_irq.c | 155 +++++++++++++++++----
linux-core/drm_lock.c | 11 +
linux-core/drm_stub.c | 1
linux-core/i915_drv.c | 4
shared-core/drm.h | 30 +++-
shared-core/drm_drawable.c | 329 +++++++++++++++++++++++++++++++++++++++++++++
shared-core/i915_dma.c | 2
shared-core/i915_drm.h | 19 ++
shared-core/i915_drv.h | 21 ++
shared-core/i915_irq.c | 281 +++++++++++++++++++++++++++++++++++---
18 files changed, 869 insertions(+), 161 deletions(-)
New commits:
diff-tree 17a640419a447083470880f1266e14063cd5acd0 (from 48367fdfe677adada52ad61d850e2980e1070632)
Author: Michel Dänzer <mi...@tu...>
Date: Fri Sep 29 10:27:29 2006 +0200
i915: Only schedule vblank tasklet if there are scheduled swaps pending.
This fixes issues on X server startup with versions of xf86-video-intel that
enable the IRQ before they have a context ID.
(cherry picked from 7af93dd9849442270ec89cb4bbeef5bfd4f9e424 commit)
diff --git a/shared-core/i915_irq.c b/shared-core/i915_irq.c
index 4f72d88..71b7230 100644
--- a/shared-core/i915_irq.c
+++ b/shared-core/i915_irq.c
@@ -176,7 +176,8 @@ irqreturn_t i915_driver_irq_handler(DRM_
DRM_WAKEUP(&dev->vbl_queue);
drm_vbl_send_signals(dev);
- drm_locked_tasklet(dev, i915_vblank_tasklet);
+ if (dev_priv->swaps_pending > 0)
+ drm_locked_tasklet(dev, i915_vblank_tasklet);
}
return IRQ_HANDLED;
diff-tree 48367fdfe677adada52ad61d850e2980e1070632 (from 3620a3ec85033d3d1d1a44ec32492fb2ef20fd8a)
Author: Michel Dänzer <mi...@tu...>
Date: Thu Sep 28 19:13:59 2006 +0200
i915: Only initialize IRQ fields in postinstall, not the PIPE_SET ioctl.
Some other minor changes in preparation for actually disabling user interrupts.
diff --git a/shared-core/i915_irq.c b/shared-core/i915_irq.c
index 6afa9ca..4f72d88 100644
--- a/shared-core/i915_irq.c
+++ b/shared-core/i915_irq.c
@@ -227,7 +227,7 @@ void i915_user_irq_off(drm_i915_private_
{
spin_lock(&dev_priv->user_irq_lock);
if (dev_priv->irq_enabled && (--dev_priv->user_irq_refcount == 0)) {
- dev_priv->irq_enable_reg &= ~USER_INT_FLAG;
+ // dev_priv->irq_enable_reg &= ~USER_INT_FLAG;
// I915_WRITE16(I915REG_INT_ENABLE_R, dev_priv->irq_enable_reg);
}
spin_unlock(&dev_priv->user_irq_lock);
@@ -344,17 +344,14 @@ int i915_irq_wait(DRM_IOCTL_ARGS)
static void i915_enable_interrupt (drm_device_t *dev)
{
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
- u16 flag;
- flag = 0;
+ dev_priv->irq_enable_reg = USER_INT_FLAG; //&= ~(VSYNC_PIPEA_FLAG | VSYNC_PIPEB_FLAG);
if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_A)
- flag |= VSYNC_PIPEA_FLAG;
+ dev_priv->irq_enable_reg |= VSYNC_PIPEA_FLAG;
if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_B)
- flag |= VSYNC_PIPEB_FLAG;
- dev_priv->user_irq_lock = SPIN_LOCK_UNLOCKED;
- dev_priv->user_irq_refcount = 0;
- dev_priv->irq_enable_reg = flag;
- I915_WRITE16(I915REG_INT_ENABLE_R, flag);
+ dev_priv->irq_enable_reg |= VSYNC_PIPEB_FLAG;
+
+ I915_WRITE16(I915REG_INT_ENABLE_R, dev_priv->irq_enable_reg);
dev_priv->irq_enabled = 1;
}
@@ -540,6 +537,9 @@ void i915_driver_irq_postinstall(drm_dev
INIT_LIST_HEAD(&dev_priv->vbl_swaps.head);
dev_priv->swaps_pending = 0;
+ dev_priv->user_irq_lock = SPIN_LOCK_UNLOCKED;
+ dev_priv->user_irq_refcount = 0;
+
if (!dev_priv->vblank_pipe)
dev_priv->vblank_pipe = DRM_I915_VBLANK_PIPE_A;
i915_enable_interrupt(dev);
diff-tree 3620a3ec85033d3d1d1a44ec32492fb2ef20fd8a (from 390184df92915d232cab90469937de875ee65b91)
Author: Michel Dänzer <mi...@tu...>
Date: Thu Sep 28 19:05:58 2006 +0200
i915: Bump minor again to differentiate from vsync changes.
diff --git a/shared-core/i915_drv.h b/shared-core/i915_drv.h
index cc57554..72cd41c 100644
--- a/shared-core/i915_drv.h
+++ b/shared-core/i915_drv.h
@@ -50,7 +50,7 @@
* - Support vertical blank on secondary display pipe
*/
#define DRIVER_MAJOR 1
-#define DRIVER_MINOR 6
+#define DRIVER_MINOR 7
#define DRIVER_PATCHLEVEL 0
#if defined(__linux__)
diff-tree 390184df92915d232cab90469937de875ee65b91 (from c0bff9f9cd08066df7f3bccd77d4d4dd4edb4163)
Author: Michel Dänzer <mi...@tu...>
Date: Wed Sep 27 18:22:10 2006 +0200
i915: Avoid mis-counting vblank interrupts when they're only enabled for pipe A.
It looks like 'after a while', I915REG_INT_IDENTITY_R for some reason always has
VSYNC_PIPEB_FLAG set in the interrupt handler, even though pipe B is disabled.
So we only increase dev->vbl_received if the corresponding bit is also set in
dev->vblank_pipe.
(cherry picked from 881ba569929ceafd42e3c86228b0172099083d1d commit)
diff --git a/shared-core/i915_irq.c b/shared-core/i915_irq.c
index b72ceb2..6afa9ca 100644
--- a/shared-core/i915_irq.c
+++ b/shared-core/i915_irq.c
@@ -158,14 +158,19 @@ irqreturn_t i915_driver_irq_handler(DRM_
}
if (temp & (VSYNC_PIPEA_FLAG | VSYNC_PIPEB_FLAG)) {
- if ((dev_priv->vblank_pipe &
+ 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->vbl_received);
if (temp & VSYNC_PIPEB_FLAG)
atomic_inc(&dev->vbl_received2);
- } else
+ } 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->vbl_received);
DRM_WAKEUP(&dev->vbl_queue);
diff-tree c0bff9f9cd08066df7f3bccd77d4d4dd4edb4163 (from 0a7d9edcfb427724f0cad5ff6d0a4493d266b4e8)
Author: Michel Dänzer <mi...@tu...>
Date: Mon Sep 18 12:15:38 2006 +0200
i915: Bump minor for swap scheduling ioctl and secondary vblank support.
(cherry picked from 2627131e5d0c8cd5e3f0db06451c2e7ae7569b1b commit)
diff --git a/shared-core/i915_drv.h b/shared-core/i915_drv.h
index c6bbcaf..cc57554 100644
--- a/shared-core/i915_drv.h
+++ b/shared-core/i915_drv.h
@@ -46,6 +46,8 @@
* 1.3: Add vblank support
* 1.4: Fix cmdbuffer path, add heap destroy
* 1.5: Add vblank pipe configuration
+ * 1.6: - New ioctl for scheduling buffer swaps on vertical blank
+ * - Support vertical blank on secondary display pipe
*/
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 6
diff-tree 0a7d9edcfb427724f0cad5ff6d0a4493d266b4e8 (from c47ebd970783873164578126fa5481a166cd837e)
Author: Michel Dänzer <mi...@tu...>
Date: Wed Sep 13 08:59:35 2006 +0200
i915_vblank_swap: Add support for DRM_VBLANK_NEXTONMISS.
(cherry picked from 0356fe260dcf80f6d2d20e3384f2a1f4ee7f5b30 commit)
diff --git a/shared-core/i915_irq.c b/shared-core/i915_irq.c
index 158a91d..b72ceb2 100644
--- a/shared-core/i915_irq.c
+++ b/shared-core/i915_irq.c
@@ -431,7 +431,7 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
sizeof(swap));
if (swap.seqtype & ~(_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE |
- _DRM_VBLANK_SECONDARY)) {
+ _DRM_VBLANK_SECONDARY | _DRM_VBLANK_NEXTONMISS)) {
DRM_ERROR("Invalid sequence type 0x%x\n", swap.seqtype);
return DRM_ERR(EINVAL);
}
@@ -440,11 +440,6 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
seqtype = swap.seqtype & (_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE);
- if (seqtype == _DRM_VBLANK_RELATIVE && swap.sequence == 0) {
- DRM_DEBUG("Not scheduling swap for current sequence\n");
- return DRM_ERR(EINVAL);
- }
-
if (!(dev_priv->vblank_pipe & (1 << pipe))) {
DRM_ERROR("Invalid pipe %d\n", pipe);
return DRM_ERR(EINVAL);
@@ -462,21 +457,20 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
curseq = atomic_read(pipe ? &dev->vbl_received2 : &dev->vbl_received);
- spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
-
- switch (seqtype) {
- case _DRM_VBLANK_RELATIVE:
+ if (seqtype == _DRM_VBLANK_RELATIVE)
swap.sequence += curseq;
- break;
- case _DRM_VBLANK_ABSOLUTE:
- if ((curseq - swap.sequence) <= (1<<23)) {
- spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+
+ if ((curseq - swap.sequence) <= (1<<23)) {
+ if (swap.seqtype & _DRM_VBLANK_NEXTONMISS) {
+ swap.sequence = curseq + 1;
+ } else {
DRM_DEBUG("Missed target sequence\n");
return DRM_ERR(EINVAL);
}
- break;
}
+ spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
+
list_for_each(list, &dev_priv->vbl_swaps.head) {
vbl_swap = list_entry(list, drm_i915_vbl_swap_t, head);
diff-tree c47ebd970783873164578126fa5481a166cd837e (from cef0f243251103be81c914d5b83ee3401c2a9c34)
Author: Michel Dänzer <mi...@tu...>
Date: Fri Sep 1 11:48:07 2006 +0200
Only return EBUSY after we've established we need to schedule a new swap.
(cherry picked from 50a0284a61d4415c0ebdb02decee76ef3115007a commit)
diff --git a/shared-core/i915_irq.c b/shared-core/i915_irq.c
index d88afdd..158a91d 100644
--- a/shared-core/i915_irq.c
+++ b/shared-core/i915_irq.c
@@ -427,11 +427,6 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
return DRM_ERR(EINVAL);
}
- if (dev_priv->swaps_pending >= 100) {
- DRM_DEBUG("Too many swaps queued\n");
- return DRM_ERR(EBUSY);
- }
-
DRM_COPY_FROM_USER_IOCTL(swap, (drm_i915_vblank_swap_t __user *) data,
sizeof(swap));
@@ -496,6 +491,11 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+ if (dev_priv->swaps_pending >= 100) {
+ DRM_DEBUG("Too many swaps queued\n");
+ return DRM_ERR(EBUSY);
+ }
+
vbl_swap = drm_calloc(1, sizeof(vbl_swap), DRM_MEM_DRIVER);
if (!vbl_swap) {
diff-tree cef0f243251103be81c914d5b83ee3401c2a9c34 (from ed82172378666d35ca60e6094fdecb59511a135f)
Author: Michel Dänzer <mi...@tu...>
Date: Fri Sep 1 11:35:31 2006 +0200
Core vsync: Don't clobber target sequence number when scheduling signal.
It looks like this would have caused signals to always get sent on the next
vertical blank, regardless of the sequence number.
(cherry picked from cf6b2c5299e9be3542d4deddfd05d5811f11d2ef commit)
diff --git a/linux-core/drm_irq.c b/linux-core/drm_irq.c
index bd8a9c8..d1a6a6b 100644
--- a/linux-core/drm_irq.c
+++ b/linux-core/drm_irq.c
@@ -295,8 +295,6 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
? &dev->vbl_sigs2 : &dev->vbl_sigs;
drm_vbl_sig_t *vbl_sig;
- vblwait.reply.sequence = seq;
-
spin_lock_irqsave(&dev->vbl_lock, irqflags);
/* Check if this task has already scheduled the same signal
@@ -309,6 +307,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
&& vbl_sig->task == current) {
spin_unlock_irqrestore(&dev->vbl_lock,
irqflags);
+ vblwait.reply.sequence = seq;
goto done;
}
}
@@ -339,6 +338,8 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
list_add_tail((struct list_head *)vbl_sig, &vbl_sigs->head);
spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
+
+ vblwait.reply.sequence = seq;
} else {
if (flags & _DRM_VBLANK_SECONDARY) {
if (dev->driver->vblank_wait2)
diff-tree ed82172378666d35ca60e6094fdecb59511a135f (from c4c47a7eacf8e8cb96b2fb63164e28f0db7353ad)
Author: Michel Dänzer <mi...@tu...>
Date: Fri Sep 1 11:27:14 2006 +0200
Core vsync: Add flag DRM_VBLANK_NEXTONMISS.
When this flag is set and the target sequence is missed, wait for the next
vertical blank instead of returning immediately.
(cherry picked from 89e323e4900af84cc33219ad24eb0b435a039d23 commit)
diff --git a/libdrm/xf86drm.h b/libdrm/xf86drm.h
index 07178ec..ae89fd6 100644
--- a/libdrm/xf86drm.h
+++ b/libdrm/xf86drm.h
@@ -252,6 +252,7 @@ typedef struct _drmTextureRegion {
typedef enum {
DRM_VBLANK_ABSOLUTE = 0x0, /**< Wait for specific vblank sequence number */
DRM_VBLANK_RELATIVE = 0x1, /**< Wait for given number of vblanks */
+ DRM_VBLANK_NEXTONMISS = 0x10000000, /**< If missed, wait for next vblank */
DRM_VBLANK_SECONDARY = 0x20000000, /**< Secondary display controller */
DRM_VBLANK_SIGNAL = 0x40000000 /* Send signal instead of blocking */
} drmVBlankSeqType;
diff --git a/linux-core/drm_irq.c b/linux-core/drm_irq.c
index fef0e8d..bd8a9c8 100644
--- a/linux-core/drm_irq.c
+++ b/linux-core/drm_irq.c
@@ -249,8 +249,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
drm_wait_vblank_t vblwait;
struct timeval now;
int ret = 0;
- unsigned int flags;
- atomic_t *seq;
+ unsigned int flags, seq;
if ((!dev->irq) || (!dev->irq_enabled))
return -EINVAL;
@@ -272,12 +271,12 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
DRIVER_IRQ_VBL2 : DRIVER_IRQ_VBL))
return -EINVAL;
- seq = (flags & _DRM_VBLANK_SECONDARY) ? &dev->vbl_received2 :
- &dev->vbl_received;
+ seq = atomic_read((flags & _DRM_VBLANK_SECONDARY) ? &dev->vbl_received2
+ : &dev->vbl_received);
switch (vblwait.request.type & _DRM_VBLANK_TYPES_MASK) {
case _DRM_VBLANK_RELATIVE:
- vblwait.request.sequence += atomic_read(seq);
+ vblwait.request.sequence += seq;
vblwait.request.type &= ~_DRM_VBLANK_RELATIVE;
case _DRM_VBLANK_ABSOLUTE:
break;
@@ -285,13 +284,18 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
return -EINVAL;
}
+ if ((flags & _DRM_VBLANK_NEXTONMISS) &&
+ (seq - vblwait.request.sequence) <= (1<<23)) {
+ vblwait.request.sequence = seq + 1;
+ }
+
if (flags & _DRM_VBLANK_SIGNAL) {
unsigned long irqflags;
drm_vbl_sig_t *vbl_sigs = (flags & _DRM_VBLANK_SECONDARY)
? &dev->vbl_sigs2 : &dev->vbl_sigs;
drm_vbl_sig_t *vbl_sig;
- vblwait.reply.sequence = atomic_read(seq);
+ vblwait.reply.sequence = seq;
spin_lock_irqsave(&dev->vbl_lock, irqflags);
diff --git a/shared-core/drm.h b/shared-core/drm.h
index 0b24111..17bf993 100644
--- a/shared-core/drm.h
+++ b/shared-core/drm.h
@@ -558,12 +558,14 @@ typedef struct drm_irq_busid {
typedef enum {
_DRM_VBLANK_ABSOLUTE = 0x0, /**< Wait for specific vblank sequence number */
_DRM_VBLANK_RELATIVE = 0x1, /**< Wait for given number of vblanks */
+ _DRM_VBLANK_NEXTONMISS = 0x10000000, /**< If missed, wait for next vblank */
_DRM_VBLANK_SECONDARY = 0x20000000, /**< Secondary display controller */
_DRM_VBLANK_SIGNAL = 0x40000000 /**< Send signal instead of blocking */
} drm_vblank_seq_type_t;
#define _DRM_VBLANK_TYPES_MASK (_DRM_VBLANK_ABSOLUTE | _DRM_VBLANK_RELATIVE)
-#define _DRM_VBLANK_FLAGS_MASK (_DRM_VBLANK_SIGNAL | _DRM_VBLANK_SECONDARY)
+#define _DRM_VBLANK_FLAGS_MASK (_DRM_VBLANK_SIGNAL | _DRM_VBLANK_SECONDARY | \
+ _DRM_VBLANK_NEXTONMISS)
struct drm_wait_vblank_request {
drm_vblank_seq_type_t type;
diff-tree c4c47a7eacf8e8cb96b2fb63164e28f0db7353ad (from f9aa4f5973d6098b95e92f606dc1967c627897db)
Author: Michel Dänzer <mi...@tu...>
Date: Fri Sep 1 11:24:38 2006 +0200
Fix 'sequence has passed' condition in i915_vblank_swap().
(cherry picked from 7f09f957d9a61ac107f8fd29128d7899a3e8a228 commit)
diff --git a/shared-core/i915_irq.c b/shared-core/i915_irq.c
index f82df5c..d88afdd 100644
--- a/shared-core/i915_irq.c
+++ b/shared-core/i915_irq.c
@@ -474,7 +474,7 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
swap.sequence += curseq;
break;
case _DRM_VBLANK_ABSOLUTE:
- if ((curseq - swap.sequence) > (1<<23)) {
+ if ((curseq - swap.sequence) <= (1<<23)) {
spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
DRM_DEBUG("Missed target sequence\n");
return DRM_ERR(EINVAL);
diff-tree f9aa4f5973d6098b95e92f606dc1967c627897db (from 316e73676861c0e019d52ec7bf7b7b1451eaed97)
Author: Michel Dänzer <mi...@tu...>
Date: Thu Aug 31 18:33:04 2006 +0200
Add SAREA fileds for determining which pipe to sync window buffer swaps to.
(cherry picked from c2bdb76814755c9ac6e66a8815f23af0fe4f3a91 commit)
diff --git a/shared-core/i915_drm.h b/shared-core/i915_drm.h
index e2a7023..9eec109 100644
--- a/shared-core/i915_drm.h
+++ b/shared-core/i915_drm.h
@@ -104,6 +104,15 @@ typedef struct _drm_i915_sarea {
unsigned int depth_tiled;
unsigned int rotated_tiled;
unsigned int rotated2_tiled;
+
+ int pipeA_x;
+ int pipeA_y;
+ int pipeA_w;
+ int pipeA_h;
+ int pipeB_x;
+ int pipeB_y;
+ int pipeB_w;
+ int pipeB_h;
} drm_i915_sarea_t;
/* Driver specific fence types and classes.
diff-tree 316e73676861c0e019d52ec7bf7b7b1451eaed97 (from 4a3d270862f6dbc52ca3e16ba66fdb24667b2aa2)
Author: Michel Dänzer <mi...@tu...>
Date: Thu Aug 31 18:32:08 2006 +0200
Add definition of DRM_VBLANK_SECONDARY.
(cherry picked from 84b38b63f05e04ade8b1ddfb770047fd86de0d64 commit)
diff --git a/libdrm/xf86drm.h b/libdrm/xf86drm.h
index d39974d..07178ec 100644
--- a/libdrm/xf86drm.h
+++ b/libdrm/xf86drm.h
@@ -252,6 +252,7 @@ typedef struct _drmTextureRegion {
typedef enum {
DRM_VBLANK_ABSOLUTE = 0x0, /**< Wait for specific vblank sequence number */
DRM_VBLANK_RELATIVE = 0x1, /**< Wait for given number of vblanks */
+ DRM_VBLANK_SECONDARY = 0x20000000, /**< Secondary display controller */
DRM_VBLANK_SIGNAL = 0x40000000 /* Send signal instead of blocking */
} drmVBlankSeqType;
diff-tree 4a3d270862f6dbc52ca3e16ba66fdb24667b2aa2 (from 1f3493f65ba0959e401191c648f57501216eeb0a)
Author: Michel Dänzer <mi...@tu...>
Date: Thu Aug 31 18:30:55 2006 +0200
Make handling of dev_priv->vblank_pipe more robust.
Initialize it to default value if it hasn't been set by the X server yet.
In i915_vblank_pipe_set(), only update dev_priv->vblank_pipe and call
i915_enable_interrupt() if the argument passed from userspace is valid to avoid
corrupting dev_priv->vblank_pipe on invalid arguments.
(cherry picked from 87c57cba1a70221fc570b253bf3b24682ef6b894 commit)
diff --git a/shared-core/i915_irq.c b/shared-core/i915_irq.c
index 3c562fd..f82df5c 100644
--- a/shared-core/i915_irq.c
+++ b/shared-core/i915_irq.c
@@ -336,7 +336,7 @@ int i915_irq_wait(DRM_IOCTL_ARGS)
return i915_wait_irq(dev, irqwait.irq_seq);
}
-static int i915_enable_interrupt (drm_device_t *dev)
+static void i915_enable_interrupt (drm_device_t *dev)
{
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
u16 flag;
@@ -346,17 +346,11 @@ static int i915_enable_interrupt (drm_de
flag |= VSYNC_PIPEA_FLAG;
if (dev_priv->vblank_pipe & DRM_I915_VBLANK_PIPE_B)
flag |= VSYNC_PIPEB_FLAG;
- if (dev_priv->vblank_pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) {
- DRM_ERROR("%s called with invalid pipe 0x%x\n",
- __FUNCTION__, dev_priv->vblank_pipe);
- return DRM_ERR(EINVAL);
- }
dev_priv->user_irq_lock = SPIN_LOCK_UNLOCKED;
dev_priv->user_irq_refcount = 0;
dev_priv->irq_enable_reg = flag;
I915_WRITE16(I915REG_INT_ENABLE_R, flag);
dev_priv->irq_enabled = 1;
- return 0;
}
/* Set the vblank monitor pipe
@@ -375,8 +369,17 @@ int i915_vblank_pipe_set(DRM_IOCTL_ARGS)
DRM_COPY_FROM_USER_IOCTL(pipe, (drm_i915_vblank_pipe_t __user *) data,
sizeof(pipe));
+ if (pipe.pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) {
+ DRM_ERROR("%s called with invalid pipe 0x%x\n",
+ __FUNCTION__, pipe.pipe);
+ return DRM_ERR(EINVAL);
+ }
+
dev_priv->vblank_pipe = pipe.pipe;
- return i915_enable_interrupt (dev);
+
+ i915_enable_interrupt (dev);
+
+ return 0;
}
int i915_vblank_pipe_get(DRM_IOCTL_ARGS)
@@ -538,6 +541,8 @@ void i915_driver_irq_postinstall(drm_dev
INIT_LIST_HEAD(&dev_priv->vbl_swaps.head);
dev_priv->swaps_pending = 0;
+ if (!dev_priv->vblank_pipe)
+ dev_priv->vblank_pipe = DRM_I915_VBLANK_PIPE_A;
i915_enable_interrupt(dev);
DRM_INIT_WAITQUEUE(&dev_priv->irq_queue);
diff-tree 1f3493f65ba0959e401191c648f57501216eeb0a (from 00531cecad3cf9a1ec230f7f33535d153b9d9bd0)
Author: Michel Dänzer <mi...@tu...>
Date: Wed Aug 30 19:33:28 2006 +0200
DRM_I915_VBLANK_SWAP ioctl: Take drm_vblank_seq_type_t instead of pipe number.
Handle relative as well as absolute target sequence numbers.
Return error if target sequence has already passed, so userspace can deal with
this situation as it sees fit.
On success, return the sequence number of the vertical blank when the buffer
swap is expected to take place.
Also add DRM_IOCTL_I915_VBLANK_SWAP definition for userspace code that may want
to use ioctl() instead of drmCommandWriteRead().
(cherry picked from d5a0f107511e128658e2d5e15bd7e6215c507f29 commit)
diff --git a/shared-core/i915_drm.h b/shared-core/i915_drm.h
index e1db7a6..e2a7023 100644
--- a/shared-core/i915_drm.h
+++ b/shared-core/i915_drm.h
@@ -159,6 +159,7 @@ typedef struct _drm_i915_sarea {
#define DRM_IOCTL_I915_DESTROY_HEAP DRM_IOW( DRM_COMMAND_BASE + DRM_I915_DESTROY_HEAP, drm_i915_mem_destroy_heap_t)
#define DRM_IOCTL_I915_SET_VBLANK_PIPE DRM_IOW( DRM_COMMAND_BASE + DRM_I915_SET_VBLANK_PIPE, drm_i915_vblank_pipe_t)
#define DRM_IOCTL_I915_GET_VBLANK_PIPE DRM_IOR( DRM_COMMAND_BASE + DRM_I915_GET_VBLANK_PIPE, drm_i915_vblank_pipe_t)
+#define DRM_IOCTL_I915_VBLANK_SWAP DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_VBLANK_SWAP, drm_i915_vblank_swap_t)
/* Allow drivers to submit batchbuffers directly to hardware, relying
@@ -259,7 +260,7 @@ typedef struct drm_i915_vblank_pipe {
*/
typedef struct drm_i915_vblank_swap {
drm_drawable_t drawable;
- unsigned int pipe;
+ drm_vblank_seq_type_t seqtype;
unsigned int sequence;
} drm_i915_vblank_swap_t;
diff --git a/shared-core/i915_irq.c b/shared-core/i915_irq.c
index 667a9ca..3c562fd 100644
--- a/shared-core/i915_irq.c
+++ b/shared-core/i915_irq.c
@@ -411,7 +411,7 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
drm_i915_private_t *dev_priv = dev->dev_private;
drm_i915_vblank_swap_t swap;
drm_i915_vbl_swap_t *vbl_swap;
- unsigned int irqflags;
+ unsigned int pipe, seqtype, irqflags, curseq;
struct list_head *list;
if (!dev_priv) {
@@ -432,8 +432,23 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
DRM_COPY_FROM_USER_IOCTL(swap, (drm_i915_vblank_swap_t __user *) data,
sizeof(swap));
- if (swap.pipe > 1 || !(dev_priv->vblank_pipe & (1 << swap.pipe))) {
- DRM_ERROR("Invalid pipe %d\n", swap.pipe);
+ if (swap.seqtype & ~(_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE |
+ _DRM_VBLANK_SECONDARY)) {
+ DRM_ERROR("Invalid sequence type 0x%x\n", swap.seqtype);
+ return DRM_ERR(EINVAL);
+ }
+
+ pipe = (swap.seqtype & _DRM_VBLANK_SECONDARY) ? 1 : 0;
+
+ seqtype = swap.seqtype & (_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE);
+
+ if (seqtype == _DRM_VBLANK_RELATIVE && swap.sequence == 0) {
+ DRM_DEBUG("Not scheduling swap for current sequence\n");
+ return DRM_ERR(EINVAL);
+ }
+
+ if (!(dev_priv->vblank_pipe & (1 << pipe))) {
+ DRM_ERROR("Invalid pipe %d\n", pipe);
return DRM_ERR(EINVAL);
}
@@ -447,13 +462,28 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+ curseq = atomic_read(pipe ? &dev->vbl_received2 : &dev->vbl_received);
+
spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
+ switch (seqtype) {
+ case _DRM_VBLANK_RELATIVE:
+ swap.sequence += curseq;
+ break;
+ case _DRM_VBLANK_ABSOLUTE:
+ if ((curseq - swap.sequence) > (1<<23)) {
+ spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+ DRM_DEBUG("Missed target sequence\n");
+ return DRM_ERR(EINVAL);
+ }
+ break;
+ }
+
list_for_each(list, &dev_priv->vbl_swaps.head) {
vbl_swap = list_entry(list, drm_i915_vbl_swap_t, head);
if (vbl_swap->drw_id == swap.drawable &&
- vbl_swap->pipe == swap.pipe &&
+ vbl_swap->pipe == pipe &&
vbl_swap->sequence == swap.sequence) {
spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
DRM_DEBUG("Already scheduled\n");
@@ -473,7 +503,7 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
DRM_DEBUG("\n");
vbl_swap->drw_id = swap.drawable;
- vbl_swap->pipe = swap.pipe;
+ vbl_swap->pipe = pipe;
vbl_swap->sequence = swap.sequence;
spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
@@ -483,6 +513,9 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+ DRM_COPY_TO_USER_IOCTL((drm_i915_vblank_swap_t __user *) data, swap,
+ sizeof(swap));
+
return 0;
}
diff-tree 00531cecad3cf9a1ec230f7f33535d153b9d9bd0 (from 7d487602a31dd886037417db088b6e643ed86918)
Author: Michel Dänzer <mi...@tu...>
Date: Wed Aug 30 19:24:04 2006 +0200
Change first valid DRM drawable ID to be 1 instead of 0.
This makes it easier for userspace to know when it needs to allocate an ID.
Also free drawable information memory when it's no longer needed.
(cherry picked from df7551ef7334d728ec0371423661bb403d3e270a commit)
diff --git a/linux-core/drm_drv.c b/linux-core/drm_drv.c
index d4ef130..37539f3 100644
--- a/linux-core/drm_drv.c
+++ b/linux-core/drm_drv.c
@@ -163,6 +163,18 @@ int drm_lastclose(drm_device_t * dev)
if (dev->irq_enabled)
drm_irq_uninstall(dev);
+ /* Free drawable information memory */
+ for (i = 0; i < dev->drw_bitfield_length / sizeof(*dev->drw_bitfield);
+ i++) {
+ drm_drawable_info_t *info = drm_get_drawable_info(dev, i);
+
+ if (info) {
+ drm_free(info->rects, info->num_rects *
+ sizeof(drm_clip_rect_t), DRM_MEM_BUFS);
+ drm_free(info, sizeof(*info), DRM_MEM_BUFS);
+ }
+ }
+
mutex_lock(&dev->struct_mutex);
del_timer(&dev->timer);
diff --git a/shared-core/drm_drawable.c b/shared-core/drm_drawable.c
index bbfaf13..5e2fc86 100644
--- a/shared-core/drm_drawable.c
+++ b/shared-core/drm_drawable.c
@@ -92,13 +92,13 @@ done:
bitfield[i] = 0;
}
- draw.handle = i * 8 * sizeof(*bitfield) + j;
+ draw.handle = i * 8 * sizeof(*bitfield) + j + 1;
DRM_DEBUG("%d\n", draw.handle);
spin_lock_irqsave(&dev->drw_lock, irqflags);
bitfield[i] |= 1 << j;
- info[draw.handle] = NULL;
+ info[draw.handle - 1] = NULL;
if (bitfield != dev->drw_bitfield) {
memcpy(bitfield, dev->drw_bitfield, dev->drw_bitfield_length *
@@ -132,7 +132,7 @@ int drm_rmdraw(DRM_IOCTL_ARGS)
{
DRM_DEVICE;
drm_draw_t draw;
- unsigned int idx, shift;
+ unsigned int id, idx, shift;
unsigned int irqflags;
u32 *bitfield = dev->drw_bitfield;
unsigned int bitfield_length = dev->drw_bitfield_length;
@@ -142,10 +142,11 @@ int drm_rmdraw(DRM_IOCTL_ARGS)
DRM_COPY_FROM_USER_IOCTL(draw, (drm_draw_t __user *) data,
sizeof(draw));
- idx = draw.handle / (8 * sizeof(*bitfield));
- shift = draw.handle % (8 * sizeof(*bitfield));
+ id = draw.handle - 1;
+ idx = id / (8 * sizeof(*bitfield));
+ shift = id % (8 * sizeof(*bitfield));
- if (idx >= bitfield_length ||
+ if (idx < 0 || idx >= bitfield_length ||
!(bitfield[idx] & (1 << shift))) {
DRM_DEBUG("No such drawable %d\n", draw.handle);
return 0;
@@ -157,6 +158,12 @@ int drm_rmdraw(DRM_IOCTL_ARGS)
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+ if (info[id]) {
+ drm_free(info[id]->rects, info[id]->num_rects *
+ sizeof(drm_clip_rect_t), DRM_MEM_BUFS);
+ drm_free(info[id], sizeof(**info), DRM_MEM_BUFS);
+ }
+
/* Can we shrink the arrays? */
if (idx == bitfield_length - 1) {
while (idx >= 0 && !bitfield[idx])
@@ -164,7 +171,7 @@ int drm_rmdraw(DRM_IOCTL_ARGS)
bitfield_length = idx + 1;
- if (idx != draw.handle / (8 * sizeof(*bitfield)))
+ if (idx != id / (8 * sizeof(*bitfield)))
bitfield = drm_alloc(bitfield_length *
sizeof(*bitfield), DRM_MEM_BUFS);
@@ -222,11 +229,12 @@ int drm_update_drawable_info(DRM_IOCTL_A
DRM_COPY_FROM_USER_IOCTL(update, (drm_update_draw_t __user *) data,
sizeof(update));
- id = update.handle;
+ id = update.handle - 1;
idx = id / (8 * sizeof(*bitfield));
shift = id % (8 * sizeof(*bitfield));
- if (idx >= bitfield_length || !(bitfield[idx] & (1 << shift))) {
+ if (idx < 0 || idx >= bitfield_length ||
+ !(bitfield[idx] & (1 << shift))) {
DRM_ERROR("No such drawable %d\n", update.handle);
return DRM_ERR(EINVAL);
}
@@ -304,10 +312,13 @@ error:
*/
drm_drawable_info_t *drm_get_drawable_info(drm_device_t *dev, drm_drawable_t id) {
u32 *bitfield = dev->drw_bitfield;
- unsigned int idx = id / (8 * sizeof(*bitfield));
- unsigned int shift = id % (8 * sizeof(*bitfield));
+ unsigned int idx, shift;
+
+ id--;
+ idx = id / (8 * sizeof(*bitfield));
+ shift = id % (8 * sizeof(*bitfield));
- if (idx >= dev->drw_bitfield_length ||
+ if (idx < 0 || idx >= dev->drw_bitfield_length ||
!(bitfield[idx] & (1 << shift))) {
DRM_DEBUG("No such drawable %d\n", id);
return NULL;
diff-tree 7d487602a31dd886037417db088b6e643ed86918 (from da75d59cd65764c6076ab9b96ad8195ed71ed80b)
Author: Michel Dänzer <mi...@tu...>
Date: Mon Aug 28 18:19:58 2006 +0200
Add copyright notice.
(cherry picked from d04751facea36cb888c7510b126658fdbc4277d5 commit)
diff --git a/shared-core/drm_drawable.c b/shared-core/drm_drawable.c
index 81eb9f0..bbfaf13 100644
--- a/shared-core/drm_drawable.c
+++ b/shared-core/drm_drawable.c
@@ -12,6 +12,7 @@
*
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+ * Copyright 2006 Tungsten Graphics, Inc., Bismarck, North Dakota.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
diff-tree da75d59cd65764c6076ab9b96ad8195ed71ed80b (from d7389a9758944ab0d241d3c1108adfeeec9eee76)
Author: Michel Dänzer <mi...@tu...>
Date: Fri Aug 25 19:01:05 2006 +0200
i915: Add ioctl for scheduling buffer swaps at vertical blanks.
This uses the core facility to schedule a driver callback that will be called
ASAP after the given vertical blank interrupt with the HW lock held.
(cherry picked from 257771fa290b62d4d2ad896843cf3a207978d0bb commit)
diff --git a/shared-core/i915_dma.c b/shared-core/i915_dma.c
index baeab38..841761c 100644
--- a/shared-core/i915_dma.c
+++ b/shared-core/i915_dma.c
@@ -163,6 +163,7 @@ static int i915_initialize(drm_device_t
dev_priv->ring.virtual_start = dev_priv->ring.map.handle;
+ dev_priv->cpp = init->cpp;
dev_priv->back_offset = init->back_offset;
dev_priv->front_offset = init->front_offset;
dev_priv->current_page = 0;
@@ -821,6 +822,7 @@ drm_ioctl_desc_t i915_ioctls[] = {
[DRM_IOCTL_NR(DRM_I915_DESTROY_HEAP)] = { i915_mem_destroy_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
[DRM_IOCTL_NR(DRM_I915_SET_VBLANK_PIPE)] = { i915_vblank_pipe_set, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
[DRM_IOCTL_NR(DRM_I915_GET_VBLANK_PIPE)] = { i915_vblank_pipe_get, DRM_AUTH },
+ [DRM_IOCTL_NR(DRM_I915_VBLANK_SWAP)] = {i915_vblank_swap, DRM_AUTH},
};
int i915_max_ioctl = DRM_ARRAY_SIZE(i915_ioctls);
diff --git a/shared-core/i915_drm.h b/shared-core/i915_drm.h
index e841105..e1db7a6 100644
--- a/shared-core/i915_drm.h
+++ b/shared-core/i915_drm.h
@@ -142,6 +142,7 @@ typedef struct _drm_i915_sarea {
#define DRM_I915_DESTROY_HEAP 0x0c
#define DRM_I915_SET_VBLANK_PIPE 0x0d
#define DRM_I915_GET_VBLANK_PIPE 0x0e
+#define DRM_I915_VBLANK_SWAP 0x0f
#define DRM_IOCTL_I915_INIT DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT, drm_i915_init_t)
#define DRM_IOCTL_I915_FLUSH DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLUSH)
@@ -254,4 +255,12 @@ typedef struct drm_i915_vblank_pipe {
int pipe;
} drm_i915_vblank_pipe_t;
+/* Schedule buffer swap at given vertical blank:
+ */
+typedef struct drm_i915_vblank_swap {
+ drm_drawable_t drawable;
+ unsigned int pipe;
+ unsigned int sequence;
+} drm_i915_vblank_swap_t;
+
#endif /* _I915_DRM_H_ */
diff --git a/shared-core/i915_drv.h b/shared-core/i915_drv.h
index 2732401..c6bbcaf 100644
--- a/shared-core/i915_drv.h
+++ b/shared-core/i915_drv.h
@@ -76,6 +76,13 @@ struct mem_block {
DRMFILE filp; /* 0: free, -1: heap, other: real files */
};
+typedef struct _drm_i915_vbl_swap {
+ struct list_head head;
+ drm_drawable_t drw_id;
+ unsigned int pipe;
+ unsigned int sequence;
+} drm_i915_vbl_swap_t;
+
typedef struct drm_i915_private {
drm_local_map_t *sarea;
drm_local_map_t *mmio_map;
@@ -88,6 +95,7 @@ typedef struct drm_i915_private {
dma_addr_t dma_status_page;
uint32_t counter;
+ unsigned int cpp;
int back_offset;
int front_offset;
int current_page;
@@ -116,6 +124,9 @@ typedef struct drm_i915_private {
uint32_t saved_flush_status;
#endif
+ spinlock_t swaps_lock;
+ drm_i915_vbl_swap_t vbl_swaps;
+ unsigned int swaps_pending;
} drm_i915_private_t;
extern drm_ioctl_desc_t i915_ioctls[];
@@ -147,6 +158,7 @@ extern int i915_vblank_pipe_get(DRM_IOCT
extern int i915_emit_irq(drm_device_t * dev);
extern void i915_user_irq_on(drm_i915_private_t *dev_priv);
extern void i915_user_irq_off(drm_i915_private_t *dev_priv);
+extern int i915_vblank_swap(DRM_IOCTL_ARGS);
/* i915_mem.c */
extern int i915_mem_alloc(DRM_IOCTL_ARGS);
@@ -304,6 +316,10 @@ extern int i915_wait_ring(drm_device_t *
#define GFX_OP_DRAWRECT_INFO_I965 ((0x7900<<16)|0x2)
+#define XY_SRC_COPY_BLT_CMD ((2<<29)|(0x53<<22)|6)
+#define XY_SRC_COPY_BLT_WRITE_ALPHA (1<<21)
+#define XY_SRC_COPY_BLT_WRITE_RGB (1<<20)
+
#define MI_BATCH_BUFFER ((0x30<<23)|1)
#define MI_BATCH_BUFFER_START (0x31<<23)
#define MI_BATCH_BUFFER_END (0xA<<23)
diff --git a/shared-core/i915_irq.c b/shared-core/i915_irq.c
index c26c276..667a9ca 100644
--- a/shared-core/i915_irq.c
+++ b/shared-core/i915_irq.c
@@ -37,6 +37,99 @@
#define MAX_NOPID ((u32)~0)
+/**
+ * Emit blits for scheduled buffer swaps.
+ *
+ * This function will be called with the HW lock held.
+ */
+static void i915_vblank_tasklet(drm_device_t *dev)
+{
+ drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+ unsigned int irqflags;
+ struct list_head *list, *tmp;
+
+ DRM_DEBUG("\n");
+
+ spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
+
+ 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);
+ atomic_t *counter = vbl_swap->pipe ? &dev->vbl_received2 :
+ &dev->vbl_received;
+
+ if ((atomic_read(counter) - vbl_swap->sequence) <= (1<<23)) {
+ drm_drawable_info_t *drw;
+
+ spin_unlock(&dev_priv->swaps_lock);
+
+ spin_lock(&dev->drw_lock);
+
+ drw = drm_get_drawable_info(dev, vbl_swap->drw_id);
+
+ if (drw) {
+ int i, num_rects = drw->num_rects;
+ drm_clip_rect_t *rect = drw->rects;
+ drm_i915_sarea_t *sarea_priv =
+ dev_priv->sarea_priv;
+ u32 cpp = dev_priv->cpp;
+ u32 cmd = (cpp == 4) ? (XY_SRC_COPY_BLT_CMD |
+ XY_SRC_COPY_BLT_WRITE_ALPHA |
+ XY_SRC_COPY_BLT_WRITE_RGB)
+ : XY_SRC_COPY_BLT_CMD;
+ u32 pitchropcpp = (sarea_priv->pitch * cpp) |
+ (0xcc << 16) | (cpp << 23) |
+ (1 << 24);
+ RING_LOCALS;
+
+ i915_kernel_lost_context(dev);
+
+ BEGIN_LP_RING(6);
+
+ OUT_RING(GFX_OP_DRAWRECT_INFO);
+ OUT_RING(0);
+ OUT_RING(0);
+ OUT_RING(sarea_priv->width |
+ sarea_priv->height << 16);
+ OUT_RING(sarea_priv->width |
+ sarea_priv->height << 16);
+ OUT_RING(0);
+
+ ADVANCE_LP_RING();
+
+ sarea_priv->ctxOwner = DRM_KERNEL_CONTEXT;
+
+ for (i = 0; i < num_rects; i++, rect++) {
+ BEGIN_LP_RING(8);
+
+ OUT_RING(cmd);
+ OUT_RING(pitchropcpp);
+ OUT_RING((rect->y1 << 16) | rect->x1);
+ OUT_RING((rect->y2 << 16) | rect->x2);
+ OUT_RING(sarea_priv->front_offset);
+ OUT_RING((rect->y1 << 16) | rect->x1);
+ OUT_RING(pitchropcpp & 0xffff);
+ OUT_RING(sarea_priv->back_offset);
+
+ ADVANCE_LP_RING();
+ }
+ }
+
+ spin_unlock(&dev->drw_lock);
+
+ spin_lock(&dev_priv->swaps_lock);
+
+ list_del(list);
+
+ drm_free(vbl_swap, sizeof(*vbl_swap), DRM_MEM_DRIVER);
+
+ dev_priv->swaps_pending--;
+ }
+ }
+
+ spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+}
+
irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
{
drm_device_t *dev = (drm_device_t *) arg;
@@ -77,6 +170,8 @@ irqreturn_t i915_driver_irq_handler(DRM_
DRM_WAKEUP(&dev->vbl_queue);
drm_vbl_send_signals(dev);
+
+ drm_locked_tasklet(dev, i915_vblank_tasklet);
}
return IRQ_HANDLED;
@@ -307,6 +402,90 @@ int i915_vblank_pipe_get(DRM_IOCTL_ARGS)
return 0;
}
+/**
+ * Schedule buffer swap at given vertical blank.
+ */
+int i915_vblank_swap(DRM_IOCTL_ARGS)
+{
+ DRM_DEVICE;
+ drm_i915_private_t *dev_priv = dev->dev_private;
+ drm_i915_vblank_swap_t swap;
+ drm_i915_vbl_swap_t *vbl_swap;
+ unsigned int irqflags;
+ struct list_head *list;
+
+ if (!dev_priv) {
+ DRM_ERROR("%s called with no initialization\n", __func__);
+ return DRM_ERR(EINVAL);
+ }
+
+ if (dev_priv->sarea_priv->rotation) {
+ DRM_DEBUG("Rotation not supported\n");
+ return DRM_ERR(EINVAL);
+ }
+
+ if (dev_priv->swaps_pending >= 100) {
+ DRM_DEBUG("Too many swaps queued\n");
+ return DRM_ERR(EBUSY);
+ }
+
+ DRM_COPY_FROM_USER_IOCTL(swap, (drm_i915_vblank_swap_t __user *) data,
+ sizeof(swap));
+
+ if (swap.pipe > 1 || !(dev_priv->vblank_pipe & (1 << swap.pipe))) {
+ DRM_ERROR("Invalid pipe %d\n", swap.pipe);
+ return DRM_ERR(EINVAL);
+ }
+
+ spin_lock_irqsave(&dev->drw_lock, irqflags);
+
+ if (!drm_get_drawable_info(dev, swap.drawable)) {
+ spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+ DRM_ERROR("Invalid drawable ID %d\n", swap.drawable);
+ return DRM_ERR(EINVAL);
+ }
+
+ spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+
+ spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
+
+ list_for_each(list, &dev_priv->vbl_swaps.head) {
+ vbl_swap = list_entry(list, drm_i915_vbl_swap_t, head);
+
+ if (vbl_swap->drw_id == swap.drawable &&
+ vbl_swap->pipe == swap.pipe &&
+ vbl_swap->sequence == swap.sequence) {
+ spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+ DRM_DEBUG("Already scheduled\n");
+ return 0;
+ }
+ }
+
+ spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+
+ vbl_swap = drm_calloc(1, sizeof(vbl_swap), DRM_MEM_DRIVER);
+
+ if (!vbl_swap) {
+ DRM_ERROR("Failed to allocate memory to queue swap\n");
+ return DRM_ERR(ENOMEM);
+ }
+
+ DRM_DEBUG("\n");
+
+ vbl_swap->drw_id = swap.drawable;
+ vbl_swap->pipe = swap.pipe;
+ vbl_swap->sequence = swap.sequence;
+
+ spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
+
+ list_add_tail((struct list_head *)vbl_swap, &dev_priv->vbl_swaps.head);
+ dev_priv->swaps_pending++;
+
+ spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
+
+ return 0;
+}
+
/* drm_dma.h hooks
*/
void i915_driver_irq_preinstall(drm_device_t * dev)
@@ -322,6 +501,10 @@ void i915_driver_irq_postinstall(drm_dev
{
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+ dev_priv->swaps_lock = SPIN_LOCK_UNLOCKED;
+ INIT_LIST_HEAD(&dev_priv->vbl_swaps.head);
+ dev_priv->swaps_pending = 0;
+
i915_enable_interrupt(dev);
DRM_INIT_WAITQUEUE(&dev_priv->irq_queue);
diff-tree d7389a9758944ab0d241d3c1108adfeeec9eee76 (from ca3a1b5ec4a417785238fb7c0cb4c3570dbcb31a)
Author: Michel Dänzer <mi...@tu...>
Date: Fri Aug 25 18:55:55 2006 +0200
Locking and memory management fixes.
(cherry picked from 23d2833aaa37a33b9ddcf06cc796f59befc0d360 commit)
diff --git a/shared-core/drm_drawable.c b/shared-core/drm_drawable.c
index 0a35794..81eb9f0 100644
--- a/shared-core/drm_drawable.c
+++ b/shared-core/drm_drawable.c
@@ -36,70 +36,86 @@
#include "drmP.h"
-/** No-op. */
+/**
+ * Allocate drawable ID and memory to store information about it.
+ */
int drm_adddraw(DRM_IOCTL_ARGS)
{
DRM_DEVICE;
unsigned int irqflags;
- int i, j = 0;
+ int i, j;
+ u32 *bitfield = dev->drw_bitfield;
+ unsigned int bitfield_length = dev->drw_bitfield_length;
+ drm_drawable_info_t **info = dev->drw_info;
+ unsigned int info_length = dev->drw_info_length;
drm_draw_t draw;
- spin_lock_irqsave(&dev->drw_lock, irqflags);
-
- for (i = 0; i < dev->drw_bitfield_length; i++) {
- u32 bitfield = dev->drw_bitfield[i];
-
- if (bitfield == ~0)
+ for (i = 0, j = 0; i < bitfield_length; i++) {
+ if (bitfield[i] == ~0)
continue;
- for (; j < sizeof(bitfield); j++)
- if (!(bitfield & (1 << j)))
+ for (; j < 8 * sizeof(*bitfield); j++)
+ if (!(bitfield[i] & (1 << j)))
goto done;
}
done:
- if (i == dev->drw_bitfield_length) {
- u32 *new_bitfield = drm_realloc(dev->drw_bitfield, i * 4,
- (i + 1) * 4, DRM_MEM_BUFS);
+ if (i == bitfield_length) {
+ bitfield_length++;
+
+ bitfield = drm_alloc(bitfield_length * sizeof(*bitfield),
+ DRM_MEM_BUFS);
- if (!new_bitfield) {
+ if (!bitfield) {
DRM_ERROR("Failed to allocate new drawable bitfield\n");
- spin_unlock_irqrestore(&dev->drw_lock, irqflags);
return DRM_ERR(ENOMEM);
}
- if (32 * (i + 1) > dev->drw_info_length) {
- void *new_info = drm_realloc(dev->drw_info,
- dev->drw_info_length *
- sizeof(drm_drawable_info_t*),
- 32 * (i + 1) *
- sizeof(drm_drawable_info_t*),
- DRM_MEM_BUFS);
+ if (8 * sizeof(*bitfield) * bitfield_length > info_length) {
+ info_length += 8 * sizeof(*bitfield);
- if (!new_info) {
+ info = drm_alloc(info_length * sizeof(*info),
+ DRM_MEM_BUFS);
+
+ if (!info) {
DRM_ERROR("Failed to allocate new drawable info"
" array\n");
- drm_free(new_bitfield, (i + 1) * 4, DRM_MEM_BUFS);
- spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+ drm_free(bitfield,
+ bitfield_length * sizeof(*bitfield),
+ DRM_MEM_BUFS);
return DRM_ERR(ENOMEM);
}
-
- dev->drw_info = (drm_drawable_info_t**)new_info;
}
- new_bitfield[i] = 0;
-
- dev->drw_bitfield = new_bitfield;
- dev->drw_bitfield_length++;
+ bitfield[i] = 0;
}
- dev->drw_bitfield[i] |= 1 << j;
-
- draw.handle = i * sizeof(u32) + j;
+ draw.handle = i * 8 * sizeof(*bitfield) + j;
DRM_DEBUG("%d\n", draw.handle);
- dev->drw_info[draw.handle] = NULL;
+ spin_lock_irqsave(&dev->drw_lock, irqflags);
+
+ bitfield[i] |= 1 << j;
+ info[draw.handle] = NULL;
+
+ if (bitfield != dev->drw_bitfield) {
+ memcpy(bitfield, dev->drw_bitfield, dev->drw_bitfield_length *
+ sizeof(*bitfield));
+ drm_free(dev->drw_bitfield, sizeof(*bitfield) *
+ dev->drw_bitfield_length, DRM_MEM_BUFS);
+ dev->drw_bitfield = bitfield;
+ dev->drw_bitfield_length = bitfield_length;
+ }
+
+ if (info != dev->drw_info) {
+ memcpy(info, dev->drw_info, dev->drw_info_length *
+ sizeof(*info));
+ drm_free(dev->drw_info, sizeof(*info) * dev->drw_info_length,
+ DRM_MEM_BUFS);
+ dev->drw_info = info;
+ dev->drw_info_length = info_length;
+ }
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
@@ -108,63 +124,85 @@ done:
return 0;
}
-/** No-op. */
+/**
+ * Free drawable ID and memory to store information about it.
+ */
int drm_rmdraw(DRM_IOCTL_ARGS)
{
DRM_DEVICE;
drm_draw_t draw;
- unsigned int idx, mod;
+ unsigned int idx, shift;
unsigned int irqflags;
+ u32 *bitfield = dev->drw_bitfield;
+ unsigned int bitfield_length = dev->drw_bitfield_length;
+ drm_drawable_info_t **info = dev->drw_info;
+ unsigned int info_length = dev->drw_info_length;
DRM_COPY_FROM_USER_IOCTL(draw, (drm_draw_t __user *) data,
sizeof(draw));
- idx = draw.handle / 32;
- mod = draw.handle % 32;
+ idx = draw.handle / (8 * sizeof(*bitfield));
+ shift = draw.handle % (8 * sizeof(*bitfield));
- spin_lock_irqsave(&dev->drw_lock, irqflags);
-
- if (idx >= dev->drw_bitfield_length ||
- !(dev->drw_bitfield[idx] & (1 << mod))) {
+ if (idx >= bitfield_length ||
+ !(bitfield[idx] & (1 << shift))) {
DRM_DEBUG("No such drawable %d\n", draw.handle);
- spin_unlock_irqrestore(&dev->drw_lock, irqflags);
return 0;
}
- dev->drw_bitfield[idx] &= ~(1 << mod);
+ spin_lock_irqsave(&dev->drw_lock, irqflags);
+
+ bitfield[idx] &= ~(1 << shift);
+
+ spin_unlock_irqrestore(&dev->drw_lock, irqflags);
- if (idx == (dev->drw_bitfield_length - 1)) {
- while (idx >= 0 && !dev->drw_bitfield[idx])
+ /* Can we shrink the arrays? */
+ if (idx == bitfield_length - 1) {
+ while (idx >= 0 && !bitfield[idx])
--idx;
- if (idx != draw.handle / 32) {
- u32 *new_bitfield = drm_realloc(dev->drw_bitfield,
- dev->drw_bitfield_length * 4,
- (idx + 1) * 4,
- DRM_MEM_BUFS);
-
- if (new_bitfield || idx == -1) {
- dev->drw_bitfield = new_bitfield;
- dev->drw_bitfield_length = idx + 1;
- }
+ bitfield_length = idx + 1;
+
+ if (idx != draw.handle / (8 * sizeof(*bitfield)))
+ bitfield = drm_alloc(bitfield_length *
+ sizeof(*bitfield), DRM_MEM_BUFS);
+
+ if (!bitfield && bitfield_length) {
+ bitfield = dev->drw_bitfield;
+ bitfield_length = dev->drw_bitfield_length;
}
}
- if (32 * dev->drw_bitfield_length < dev->drw_info_length) {
- void *new_info = drm_realloc(dev->drw_info,
- dev->drw_info_length *
- sizeof(drm_drawable_info_t*),
- 32 * dev->drw_bitfield_length *
- sizeof(drm_drawable_info_t*),
- DRM_MEM_BUFS);
-
- if (new_info || !dev->drw_bitfield_length) {
- dev->drw_info = (drm_drawable_info_t**)new_info;
- dev->drw_info_length = 32 * dev->drw_bitfield_length;
+ if (bitfield != dev->drw_bitfield) {
+ info_length = 8 * sizeof(*bitfield) * bitfield_length;
+
+ info = drm_alloc(info_length * sizeof(*info), DRM_MEM_BUFS);
+
+ if (!info && info_length) {
+ info = dev->drw_info;
+ info_length = dev->drw_info_length;
}
- }
- spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+ spin_lock_irqsave(&dev->drw_lock, irqflags);
+
+ memcpy(bitfield, dev->drw_bitfield, bitfield_length *
+ sizeof(*bitfield));
+ drm_free(dev->drw_bitfield, sizeof(*bitfield) *
+ dev->drw_bitfield_length, DRM_MEM_BUFS);
+ dev->drw_bitfield = bitfield;
+ dev->drw_bitfield_length = bitfield_length;
+
+ if (info != dev->drw_info) {
+ memcpy(info, dev->drw_info, info_length *
+ sizeof(*info));
+ drm_free(dev->drw_info, sizeof(*info) *
+ dev->drw_info_length, DRM_MEM_BUFS);
+ dev->drw_info = info;
+ dev->drw_info_length = info_length;
+ }
+
+ spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+ }
DRM_DEBUG("%d\n", draw.handle);
return 0;
@@ -173,24 +211,22 @@ int drm_rmdraw(DRM_IOCTL_ARGS)
int drm_update_drawable_info(DRM_IOCTL_ARGS) {
DRM_DEVICE;
drm_update_draw_t update;
- unsigned int id, idx, mod;
- unsigned int irqflags;
+ unsigned int id, idx, shift;
+ u32 *bitfield = dev->drw_bitfield;
+ unsigned int irqflags, bitfield_length = dev->drw_bitfield_length;
drm_drawable_info_t *info;
- void *new_data;
+ drm_clip_rect_t *rects;
+ int err;
DRM_COPY_FROM_USER_IOCTL(update, (drm_update_draw_t __user *) data,
sizeof(update));
id = update.handle;
- idx = id / 32;
- mod = id % 32;
-
- spin_lock_irqsave(&dev->drw_lock, irqflags);
+ idx = id / (8 * sizeof(*bitfield));
+ shift = id % (8 * sizeof(*bitfield));
- if (idx >= dev->drw_bitfield_length ||
- !(dev->drw_bitfield[idx] & (1 << mod))) {
+ if (idx >= bitfield_length || !(bitfield[idx] & (1 << shift))) {
DRM_ERROR("No such drawable %d\n", update.handle);
- spin_unlock_irqrestore(&dev->drw_lock, irqflags);
return DRM_ERR(EINVAL);
}
@@ -201,66 +237,77 @@ int drm_update_drawable_info(DRM_IOCTL_A
if (!info) {
DRM_ERROR("Failed to allocate drawable info memory\n");
- spin_unlock_irqrestore(&dev->drw_lock, irqflags);
return DRM_ERR(ENOMEM);
}
-
- dev->drw_info[id] = info;
}
switch (update.type) {
case DRM_DRAWABLE_CLIPRECTS:
if (update.num != info->num_rects) {
- new_data = drm_alloc(update.num *
- sizeof(drm_clip_rect_t),
- DRM_MEM_BUFS);
-
- if (!new_data) {
- DRM_ERROR("Can't allocate cliprect memory\n");
- spin_unlock_irqrestore(&dev->drw_lock, irqflags);
- return DRM_ERR(ENOMEM);
- }
-
- info->rects = new_data;
+ rects = drm_alloc(update.num * sizeof(drm_clip_rect_t),
+ DRM_MEM_BUFS);
+ } else
+ rects = info->rects;
+
+ if (update.num && !rects) {
+ DRM_ERROR("Failed to allocate cliprect memory\n");
+ err = DRM_ERR(ENOMEM);
+ goto error;
}
- if (DRM_COPY_FROM_USER(info->rects,
- (drm_clip_rect_t __user *)
- (unsigned long)update.data,
- update.num * sizeof(drm_clip_rect_t))) {
- DRM_ERROR("Can't copy cliprects from userspace\n");
- spin_unlock_irqrestore(&dev->drw_lock, irqflags);
- return DRM_ERR(EFAULT);
+ if (update.num && DRM_COPY_FROM_USER(rects,
+ (drm_clip_rect_t __user *)
+ (unsigned long)update.data,
+ update.num *
+ sizeof(*rects))) {
+ DRM_ERROR("Failed to copy cliprects from userspace\n");
+ err = DRM_ERR(EFAULT);
+ goto error;
}
- if (update.num != info->num_rects) {
+ spin_lock_irqsave(&dev->drw_lock, irqflags);
+
+ if (rects != info->rects) {
drm_free(info->rects, info->num_rects *
sizeof(drm_clip_rect_t), DRM_MEM_BUFS);
- info->num_rects = update.num;
}
+ info->rects = rects;
+ info->num_rects = update.num;
+ dev->drw_info[id] = info;
+
+ spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+
DRM_DEBUG("Updated %d cliprects for drawable %d\n",
info->num_rects, id);
break;
default:
DRM_ERROR("Invalid update type %d\n", update.type);
- spin_unlock_irqrestore(&dev->drw_lock, irqflags);
return DRM_ERR(EINVAL);
}
- spin_unlock_irqrestore(&dev->drw_lock, irqflags);
-
return 0;
+
+error:
+ if (!dev->drw_info[id])
+ drm_free(info, sizeof(*info), DRM_MEM_BUFS);
+ else if (rects != dev->drw_info[id]->rects)
+ drm_free(rects, update.num *
+ sizeof(drm_clip_rect_t), DRM_MEM_BUFS);
+
+ return err;
}
/**
* Caller must hold the drawable spinlock!
*/
drm_drawable_info_t *drm_get_drawable_info(drm_device_t *dev, drm_drawable_t id) {
- unsigned int idx = id / 32, mod = id % 32;
+ u32 *bitfield = dev->drw_bitfield;
+ unsigned int idx = id / (8 * sizeof(*bitfield));
+ unsigned int shift = id % (8 * sizeof(*bitfield));
if (idx >= dev->drw_bitfield_length ||
- !(dev->drw_bitfield[idx] & (1 << mod))) {
+ !(bitfield[idx] & (1 << shift))) {
DRM_DEBUG("No such drawable %d\n", id);
return NULL;
}
diff-tree ca3a1b5ec4a417785238fb7c0cb4c3570dbcb31a (from f93e4822694b066427f70c23216b78f92edb1bff)
Author: Michel Dänzer <mi...@tu...>
Date: Fri Aug 25 18:55:06 2006 +0200
Drop tasklet locked driver callback when uninstalling IRQ.
(cherry picked from b9f3009160d8bd1a26a77d6f1616f1679c7b969d commit)
diff --git a/linux-core/drm_irq.c b/linux-core/drm_irq.c
index b57fffb..fef0e8d 100644
--- a/linux-core/drm_irq.c
+++ b/linux-core/drm_irq.c
@@ -176,6 +176,8 @@ int drm_irq_uninstall(drm_device_t * dev
free_irq(dev->irq, dev);
+ dev->locked_tasklet_func = NULL;
+
return 0;
}
EXPORT_SYMBOL(drm_irq_uninstall);
diff-tree f93e4822694b066427f70c23216b78f92edb1bff (from 67e88e5628d02cd94561e31fd68e02b6bde66e6f)
Author: Michel Dänzer <mi...@tu...>
Date: Wed Aug 23 19:00:26 2006 +0200
Export drm_get_drawable_info symbol from core.
(cherry picked from 43f8675534c7e95efbc92eaf2c8cc43aef95f125 commit)
diff --git a/shared-core/drm_drawable.c b/shared-core/drm_drawable.c
index 511f3ea..0a35794 100644
--- a/shared-core/drm_drawable.c
+++ b/shared-core/drm_drawable.c
@@ -267,3 +267,4 @@ drm_drawable_info_t *drm_get_drawable_in
return dev->drw_info[id];
}
+EXPORT_SYMBOL(drm_get_drawable_info);
diff-tree 67e88e5628d02cd94561e31fd68e02b6bde66e6f (from baa26c5faa3d5903569d1c94ad93b843d6979ba5)
Author: Michel Dänzer <mi...@tu...>
Date: Wed Aug 23 16:05:47 2006 +0200
Hook up DRM_IOCTL_UPDATE_DRAW ioctl.
(cherry picked from 98a89504589427a76c3f5cfa2266962a1a212672 commit)
diff --git a/linux-core/drmP.h b/linux-core/drmP.h
index 8a099ba..8b3364e 100644
--- a/linux-core/drmP.h
+++ b/linux-core/drmP.h
@@ -1169,6 +1169,8 @@ extern int drm_adddraw(struct inode *ino
unsigned int cmd, unsigned long arg);
extern int drm_rmdraw(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg);
+extern int drm_update_drawable_info(struct inode *inode, struct file *filp,
+ unsigned int cmd, unsigned long arg);
extern drm_drawable_info_t *drm_get_drawable_info(drm_device_t *dev,
drm_drawable_t id);
diff --git a/linux-core/drm_drv.c b/linux-core/drm_drv.c
index 89b20a9..d4ef130 100644
--- a/linux-core/drm_drv.c
+++ b/linux-core/drm_drv.c
@@ -123,7 +123,9 @@ static drm_ioctl_desc_t drm_ioctls[] = {
[DRM_IOCTL_NR(DRM_IOCTL_TTM)] = {drm_ttm_ioctl, DRM_AUTH},
[DRM_IOCTL_NR(DRM_IOCTL_BUFOBJ)] = {drm_bo_ioctl, DRM_AUTH},
[DRM_IOCTL_NR(DRM_IOCTL_MM_INIT)] = {drm_mm_init_ioctl,
- DRM_AUTH }
+ DRM_AUTH },
+
+ [DRM_IOCTL_NR(DRM_IOCTL_UPDATE_DRAW)] = {drm_update_drawable_info, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
};
#define DRIVER_IOCTL_COUNT ARRAY_SIZE( drm_ioctls )
diff-tree baa26c5faa3d5903569d1c94ad93b843d6979ba5 (from 9810ec2737de6aa81e764225f580e4ea39de437a)
Author: Michel Dänzer <mi...@tu...>
Date: Wed Aug 23 16:04:41 2006 +0200
Only reallocate cliprect memory if the number of cliprects changes.
Also improve diagnostic output.
(cherry picked from af48be1096221d551319c67a9e782b50ef58fefd commit)
diff --git a/shared-core/drm_drawable.c b/shared-core/drm_drawable.c
index ca6eb81..511f3ea 100644
--- a/shared-core/drm_drawable.c
+++ b/shared-core/drm_drawable.c
@@ -166,6 +166,7 @@ int drm_rmdraw(DRM_IOCTL_ARGS)
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+ DRM_DEBUG("%d\n", draw.handle);
return 0;
}
@@ -209,30 +210,42 @@ int drm_update_drawable_info(DRM_IOCTL_A
switch (update.type) {
case DRM_DRAWABLE_CLIPRECTS:
- new_data = drm_alloc(update.num * sizeof(drm_clip_rect_t),
- DRM_MEM_BUFS);
+ if (update.num != info->num_rects) {
+ new_data = drm_alloc(update.num *
+ sizeof(drm_clip_rect_t),
+ DRM_MEM_BUFS);
+
+ if (!new_data) {
+ DRM_ERROR("Can't allocate cliprect memory\n");
+ spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+ return DRM_ERR(ENOMEM);
+ }
- if (!new_data) {
- DRM_ERROR("Failed to allocate cliprect memory\n");
- spin_unlock_irqrestore(&dev->drw_lock, irqflags);
- return DRM_ERR(ENOMEM);
+ info->rects = new_data;
}
- if (DRM_COPY_FROM_USER(new_data,
+ if (DRM_COPY_FROM_USER(info->rects,
(drm_clip_rect_t __user *)
(unsigned long)update.data,
update.num * sizeof(drm_clip_rect_t))) {
- DRM_ERROR("Failed to copy cliprects from userspace\n");
+ DRM_ERROR("Can't copy cliprects from userspace\n");
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
return DRM_ERR(EFAULT);
}
- drm_free(info->rects, info->num_rects * sizeof(drm_clip_rect_t),
- DRM_MEM_BUFS);
+ if (update.num != info->num_rects) {
+ drm_free(info->rects, info->num_rects *
+ sizeof(drm_clip_rect_t), DRM_MEM_BUFS);
+ info->num_rects = update.num;
+ }
- info->rects = new_data;
- info->num_rects = update.num;
+ DRM_DEBUG("Updated %d cliprects for drawable %d\n",
+ info->num_rects, id);
break;
+ default:
+ DRM_ERROR("Invalid update type %d\n", update.type);
+ spin_unlock_irqrestore(&dev->drw_lock, irqflags);
+ return DRM_ERR(EINVAL);
}
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
diff-tree 9810ec2737de6aa81e764225f580e4ea39de437a (from a7b8c8d523d7f726b8fb74cb37f807d2316cf5dd)
Author: Michel Dänzer <mi...@tu...>
Date: Tue Aug 22 16:40:07 2006 +0200
Add support for tracking drawable information to core
Actually make the existing ioctls for adding and removing drawables do
something useful, and add another ioctl for the X server to update drawable
information. The only kind of drawable information tracked so far is cliprects.
(cherry picked from 29598e5253ff5c085ccf63580fd24b84db848424 commit)
diff --git a/bsd-core/drm_drawable.c b/bsd-core/drm_drawable.c
deleted file mode 100644
index 379e0aa..d64bbe1
--- a/bsd-core/drm_drawable.c
+++ /dev/null
@@ -1,51 +0,0 @@
-/* drm_drawable.h -- IOCTLs for drawables -*- linux-c -*-
- * Created: Tue Feb 2 08:37:54 1999 by fa...@va...
- */
-/*-
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * 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, sublicense,
- * 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 NONINFRINGEMENT. IN NO EVENT SHALL
- * VA LINUX SYSTEMS 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.
- *
- * Authors:
- * Rickard E. (Rik) Faith <fa...@va...>
- * Gareth Hughes <ga...@va...>
- *
- */
-
-#include "drmP.h"
-
-int drm_adddraw(DRM_IOCTL_ARGS)
-{
- drm_draw_t draw;
-
- draw.handle = 0; /* NOOP */
- DRM_DEBUG("%d\n", draw.handle);
-
- DRM_COPY_TO_USER_IOCTL( (drm_draw_t *)data, draw, sizeof(draw) );
-
- return 0;
-}
-
-int drm_rmdraw(DRM_IOCTL_ARGS)
-{
- return 0; /* NOOP */
-}
diff --git a/bsd-core/drm_drawable.c b/bsd-core/drm_drawable.c
new file mode 120000
index 379e0aa..d64bbe1
--- /dev/null
+++ b/bsd-core/drm_drawable.c
@@ -0,0 +1 @@
+../shared-core/drm_drawable.c
\ No newline at end of file
diff --git a/libdrm/xf86drm.c b/libdrm/xf86drm.c
index 31d1c16..ab884eb 100644
--- a/libdrm/xf86drm.c
+++ b/libdrm/xf86drm.c
@@ -1398,6 +1398,22 @@ int drmDestroyDrawable(int fd, drm_drawa
return 0;
}
+int drmUpdateDrawableInfo(int fd, drm_drawable_t handle,
+ drm_drawable_info_type_t type, unsigned int num,
+ void *data)
+{
+ drm_update_draw_t update;
+
+ update.handle = handle;
+ update.type = type;
+ update.num = num;
+ update.data = (unsigned long long)(unsigned long)data;
+
+ if (ioctl(fd, DRM_IOCTL_UPDATE_DRAW, &update)) return -errno;
+
+ return 0;
+}
+
/**
* Acquire the AGP device.
*
diff --git a/libdrm/xf86drm.h b/libdrm/xf86drm.h
index d97681c..d39974d 100644
--- a/libdrm/xf86drm.h
+++ b/libdrm/xf86drm.h
@@ -545,6 +545,9 @@ extern int drmSwitchToContext(
extern int drmDestroyContext(int fd, drm_context_t handle);
extern int drmCreateDrawable(int fd, drm_drawable_t * handle);
extern int drmDestroyDrawable(int fd, drm_drawable_t handle);
+extern int drmUpdateDrawableInfo(int fd, drm_drawable_t handle,
+ drm_drawable_info_type_t type,
+ unsigned int num, void *data);
extern int drmCtlInstHandler(int fd, int irq);
extern int drmCtlUninstHandler(int fd);
diff --git a/linux-core/Makefile b/linux-core/Makefile
index 32828d2..3aecec4 100644
--- a/linux-core/Makefile
+++ b/linux-core/Makefile
@@ -75,8 +75,8 @@ DRM_MODULES ?= $(MODULE_LIST)
# These definitions are for handling dependencies in the out of kernel build.
-DRMSHARED = drm.h drm_sarea.h
-DRMHEADERS = drmP.h drm_compat.h drm_os_linux.h $(DRMSHARED)
+DRMSHARED = drm.h drm_sarea.h drm_drawable.c
+DRMHEADERS = drmP.h drm_compat.h drm_os_linux.h drm.h drm_sarea.h
COREHEADERS = drm_core.h drm_sman.h drm_hashtab.h
TDFXHEADERS = tdfx_drv.h $(DRMHEADERS)
diff --git a/linux-core/drmP.h b/linux-core/drmP.h
index 60354bc..8a099ba 100644
--- a/linux-core/drmP.h
+++ b/linux-core/drmP.h
@@ -954,6 +954,14 @@ typedef struct drm_device {
drm_fence_manager_t fm;
drm_buffer_manager_t bm;
+ /** \name Drawable information */
+ /*@{ */
+ spinlock_t drw_lock;
+ unsigned int drw_bitfield_length;
+ u32 *drw_bitfield;
+ unsigned int drw_info_length;
+ drm_drawable_info_t **drw_info;
+ /*@} */
} drm_device_t;
#if __OS_HAS_AGP
@@ -1161,6 +1169,8 @@ extern int drm_adddraw(struct inode *ino
unsigned int cmd, unsigned long arg);
extern int drm_rmdraw(s...
[truncated message content] |