* [PATCH 1/2] glamor: Move flags check to intel_glamor.
@ 2011-11-15 11:36 Zhigang Gong
2011-11-15 11:36 ` [PATCH 2/2] glamor: Address GLAMOR/UXA flushing problem Zhigang Gong
2011-11-15 12:10 ` [PATCH 1/2] glamor: Move flags check to intel_glamor Chris Wilson
0 siblings, 2 replies; 6+ messages in thread
From: Zhigang Gong @ 2011-11-15 11:36 UTC (permalink / raw)
To: intel-gfx
Address Chris comment. We concentrate all the flag check into
intel_glamor layer which makes the interface to glamor
self-contained.
Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
---
src/Makefile.am | 6 +---
src/intel_driver.c | 25 +++++------------
src/intel_glamor.c | 75 +++++++++++++++++++++++++++++++++++++++++++++------
src/intel_uxa.c | 31 +++++----------------
4 files changed, 82 insertions(+), 55 deletions(-)
diff --git a/src/Makefile.am b/src/Makefile.am
index 1a29390..12ff6ee 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -40,10 +40,6 @@ SUBDIRS += sna
intel_drv_la_LIBADD += sna/libsna.la
endif
-if GLAMOR
-GLAMOR_SOURCE = intel_glamor.c
-endif
-
NULL:=#
intel_drv_la_SOURCES = \
@@ -74,7 +70,7 @@ intel_drv_la_SOURCES = \
i965_3d.c \
i965_video.c \
i965_render.c \
- $(GLAMOR_SOURCE) \
+ intel_glamor.c \
$(NULL)
if DRI
diff --git a/src/intel_driver.c b/src/intel_driver.c
index 0f528f3..2cc418e 100644
--- a/src/intel_driver.c
+++ b/src/intel_driver.c
@@ -714,19 +714,12 @@ static Bool I830PreInit(ScrnInfoPtr scrn, int flags)
return FALSE;
}
-#ifdef GLAMOR
- /* Load glamor module */
- if (!xf86LoadSubModule(scrn, "glamor_egl")) {
- PreInitCleanup(scrn);
- return FALSE;
- }
-
- if (!intel_glamor_pre_init(scrn)) {
- xf86DrvMsg(scrn->scrnIndex, X_ERROR,
- "Failed to pre init glamor display.\n");
- return FALSE;
- }
-#endif
+ if (!intel_glamor_pre_init(scrn)) {
+ PreInitCleanup(scrn);
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR,
+ "Failed to pre init glamor display.\n");
+ return FALSE;
+ }
/* Load the dri2 module if requested. */
if (intel->directRenderingType != DRI_DISABLED)
@@ -1126,8 +1119,7 @@ static void I830FreeScreen(int scrnIndex, int flags)
ScrnInfoPtr scrn = xf86Screens[scrnIndex];
intel_screen_private *intel = intel_get_screen_private(scrn);
- if (intel->uxa_flags & UXA_GLAMOR_FLAGS)
- intel_glamor_free_screen(scrnIndex, flags);
+ intel_glamor_free_screen(scrnIndex, flags);
if (intel) {
intel_mode_fini(intel);
@@ -1208,8 +1200,7 @@ static Bool I830CloseScreen(int scrnIndex, ScreenPtr screen)
DeleteCallback(&FlushCallback, intel_flush_callback, scrn);
- if (intel->uxa_flags & UXA_GLAMOR_FLAGS)
- intel_glamor_close_screen(screen);
+ intel_glamor_close_screen(screen);
if (intel->uxa_driver) {
uxa_driver_fini(screen);
diff --git a/src/intel_glamor.c b/src/intel_glamor.c
index cadfc71..80cde40 100644
--- a/src/intel_glamor.c
+++ b/src/intel_glamor.c
@@ -48,6 +48,9 @@ intel_glamor_create_screen_resources(ScreenPtr screen)
ScrnInfoPtr scrn = xf86Screens[screen->myNum];
intel_screen_private *intel = intel_get_screen_private(scrn);
+ if (!(intel->uxa_flags & UXA_GLAMOR_FLAGS))
+ return TRUE;
+
if (!glamor_glyphs_init(screen))
return FALSE;
if (!glamor_egl_create_textured_screen(screen,
@@ -60,57 +63,100 @@ intel_glamor_create_screen_resources(ScreenPtr screen)
Bool
intel_glamor_pre_init(ScrnInfoPtr scrn)
{
+#ifdef GLAMOR
intel_screen_private *intel;
intel = intel_get_screen_private(scrn);
+
+ /* Load glamor module */
+ if (!xf86LoadSubModule(scrn, "glamor_egl"))
+ return FALSE;
+
return glamor_egl_init(scrn, intel->drmSubFD);
+#else
+ return TRUE;
+#endif
}
Bool
intel_glamor_create_textured_pixmap(PixmapPtr pixmap)
{
struct intel_pixmap *priv;
+ ScrnInfoPtr scrn = xf86Screens[pixmap->drawable.pScreen->myNum];
+ intel_screen_private * intel;
+
priv = intel_get_pixmap_private(pixmap);
- return glamor_egl_create_textured_pixmap(pixmap, priv->bo->handle,
- priv->stride);
+ intel = intel_get_screen_private(scrn);
+ if ((intel->uxa_flags & UXA_GLAMOR_FLAGS)
+ && glamor_egl_create_textured_pixmap(pixmap, priv->bo->handle,
+ priv->stride)) {
+ priv->pinned = 1;
+ return TRUE;
+ }
+ return FALSE;
}
void
intel_glamor_destroy_pixmap(PixmapPtr pixmap)
{
- glamor_egl_destroy_textured_pixmap(pixmap);
+ ScrnInfoPtr scrn = xf86Screens[pixmap->drawable.pScreen->myNum];
+ intel_screen_private * intel;
+
+ intel = intel_get_screen_private(scrn);
+ if (intel->uxa_flags & UXA_GLAMOR_FLAGS)
+ glamor_egl_destroy_textured_pixmap(pixmap);
}
Bool
intel_glamor_init(ScreenPtr screen)
{
+#ifdef GLAMOR
ScrnInfoPtr scrn = xf86Screens[screen->myNum];
+ intel_screen_private * intel;
+
if (!glamor_init(screen, GLAMOR_INVERTED_Y_AXIS)) {
xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Failed to initialize glamor\n");
- return FALSE;
+ goto fail;
}
if (!glamor_egl_init_textured_pixmap(screen)) {
xf86DrvMsg(scrn->scrnIndex, X_ERROR,
- "Failed to initialize glamor\n");
- return FALSE;
+ "Failed to initialize textured pixmap.\n");
+ goto fail;
}
+ intel = intel_get_screen_private(scrn);
+ intel->uxa_driver->flags |= UXA_USE_GLAMOR;
+ intel->uxa_flags = intel->uxa_driver->flags;
+
+ xf86DrvMsg(scrn->scrnIndex, X_INFO,
+ "Use GLAMOR acceleration.\n");
return TRUE;
+
+ fail:
+ xf86DrvMsg(scrn->scrnIndex, X_WARNING,
+ "Use standard UXA acceleration.");
+ return FALSE;
+#else
+ return TRUE;
+#endif
}
void
intel_glamor_block_handler(intel_screen_private * intel)
{
ScreenPtr screen = screenInfo.screens[intel->scrn->scrnIndex];
- glamor_block_handler(screen);
+
+ if (intel->uxa_flags & UXA_GLAMOR_FLAGS)
+ glamor_block_handler(screen);
}
Bool
intel_glamor_create_screen_image(ScreenPtr screen, int handle, int stride)
{
PixmapPtr pixmap;
+
if (!glamor_egl_create_textured_screen(screen, handle, stride))
return FALSE;
pixmap = screen->GetScreenPixmap(screen);
@@ -120,11 +166,22 @@ intel_glamor_create_screen_image(ScreenPtr screen, int handle, int stride)
Bool
intel_glamor_close_screen(ScreenPtr screen)
{
- return glamor_egl_close_screen(screen);
+ ScrnInfoPtr scrn = xf86Screens[screen->myNum];
+ intel_screen_private * intel;
+
+ intel = intel_get_screen_private(scrn);
+ if (intel && (intel->uxa_flags & UXA_GLAMOR_FLAGS))
+ return glamor_egl_close_screen(screen);
+ return TRUE;
}
void
intel_glamor_free_screen(int scrnIndex, int flags)
{
- glamor_egl_free_screen(scrnIndex, GLAMOR_EGL_EXTERNAL_BUFFER);
+ ScrnInfoPtr scrn = xf86Screens[scrnIndex];
+ intel_screen_private * intel;
+
+ intel = intel_get_screen_private(scrn);
+ if (intel && (intel->uxa_flags & UXA_GLAMOR_FLAGS))
+ glamor_egl_free_screen(scrnIndex, GLAMOR_EGL_EXTERNAL_BUFFER);
}
diff --git a/src/intel_uxa.c b/src/intel_uxa.c
index 81d5ec0..5202076 100644
--- a/src/intel_uxa.c
+++ b/src/intel_uxa.c
@@ -966,8 +966,7 @@ void intel_uxa_block_handler(intel_screen_private *intel)
* and beyond rendering results may not hit the
* framebuffer until significantly later.
*/
- if (intel->uxa_flags & UXA_GLAMOR_FLAGS)
- intel_glamor_block_handler(intel);
+ intel_glamor_block_handler(intel);
intel_flush_rendering(intel);
}
@@ -1100,10 +1099,7 @@ intel_uxa_create_pixmap(ScreenPtr screen, int w, int h, int depth,
list_init(&priv->flush);
intel_set_pixmap_private(pixmap, priv);
- if (intel->uxa_flags & UXA_GLAMOR_FLAGS) {
- priv->pinned = 1;
- intel_glamor_create_textured_pixmap(pixmap);
- }
+ intel_glamor_create_textured_pixmap(pixmap);
}
return pixmap;
@@ -1111,11 +1107,8 @@ intel_uxa_create_pixmap(ScreenPtr screen, int w, int h, int depth,
static Bool intel_uxa_destroy_pixmap(PixmapPtr pixmap)
{
- ScrnInfoPtr scrn = xf86Screens[pixmap->drawable.pScreen->myNum];
- intel_screen_private *intel = intel_get_screen_private(scrn);
if (pixmap->refcnt == 1) {
- if (intel->uxa_flags & UXA_GLAMOR_FLAGS)
- intel_glamor_destroy_pixmap(pixmap);
+ intel_glamor_destroy_pixmap(pixmap);
intel_set_pixmap_bo(pixmap, NULL);
}
fbDestroyPixmap(pixmap);
@@ -1148,8 +1141,7 @@ Bool intel_uxa_create_screen_resources(ScreenPtr screen)
scrn->displayWidth = intel->front_pitch / intel->cpp;
}
- if ((intel->uxa_flags & UXA_GLAMOR_FLAGS)
- && !intel_glamor_create_screen_resources(screen))
+ if (!intel_glamor_create_screen_resources(screen))
return FALSE;
return TRUE;
@@ -1313,17 +1305,8 @@ Bool intel_uxa_init(ScreenPtr screen)
uxa_set_fallback_debug(screen, intel->fallback_debug);
uxa_set_force_fallback(screen, intel->force_fallback);
-#ifdef GLAMOR
- if (intel_glamor_init(screen)) {
- xf86DrvMsg(scrn->scrnIndex, X_INFO,
- "Intel GLAMOR initialization successfully.\n");
- intel->uxa_driver->flags |= UXA_USE_GLAMOR;
- intel->uxa_flags = intel->uxa_driver->flags;
- } else {
- xf86DrvMsg(scrn->scrnIndex, X_WARNING,
- "Intel GLAMOR initialization failed,"
- "change to use standard UXA.\n");
- }
-#endif
+
+ intel_glamor_init(screen);
+
return TRUE;
}
--
1.7.4.4
^ permalink raw reply related [flat|nested] 6+ messages in thread* [PATCH 2/2] glamor: Address GLAMOR/UXA flushing problem.
2011-11-15 11:36 [PATCH 1/2] glamor: Move flags check to intel_glamor Zhigang Gong
@ 2011-11-15 11:36 ` Zhigang Gong
2011-11-15 12:24 ` Chris Wilson
2011-11-15 12:10 ` [PATCH 1/2] glamor: Move flags check to intel_glamor Chris Wilson
1 sibling, 1 reply; 6+ messages in thread
From: Zhigang Gong @ 2011-11-15 11:36 UTC (permalink / raw)
To: intel-gfx
This commit introduces a new function in UXA layer need_flush
which is used to let the UXA layer to notify the lower layer
that some pixmap get modified by GLAMOR. And then the intel
driver could know it need to flush front buffer latter.
This commit also adds some necessary flushing pointis for UXA
layer and glamor layer. Basicly, there are three scenarios:
1. Before calling into glamor layer, it needs to flush all the
corresponding UXA batch comand buffer.
2. After calling the glamor rendering functions, it needs to
flush the pending GL operations.
3. Before we map a pixmap's BO, we also need to flush all the
pending GL operations.
The scenario 2 could be eliminated when we fully change to glamor
path.
Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>
---
src/intel_glamor.c | 13 ++++++++++++-
src/intel_uxa.c | 8 +++++++-
uxa/uxa-accel.c | 30 ++++++++++++++++++++++++------
uxa/uxa.h | 16 +++++++++++++++-
4 files changed, 58 insertions(+), 9 deletions(-)
diff --git a/src/intel_glamor.c b/src/intel_glamor.c
index 80cde40..0920c05 100644
--- a/src/intel_glamor.c
+++ b/src/intel_glamor.c
@@ -106,6 +106,16 @@ intel_glamor_destroy_pixmap(PixmapPtr pixmap)
glamor_egl_destroy_textured_pixmap(pixmap);
}
+static void
+intel_glamor_need_flush(DrawablePtr pDrawable)
+{
+ ScrnInfoPtr scrn = xf86Screens[pDrawable->pScreen->myNum];
+ intel_screen_private * intel;
+
+ intel = intel_get_screen_private(scrn);
+ intel->needs_flush = TRUE;
+}
+
Bool
intel_glamor_init(ScreenPtr screen)
{
@@ -113,7 +123,6 @@ intel_glamor_init(ScreenPtr screen)
ScrnInfoPtr scrn = xf86Screens[screen->myNum];
intel_screen_private * intel;
-
if (!glamor_init(screen, GLAMOR_INVERTED_Y_AXIS)) {
xf86DrvMsg(scrn->scrnIndex, X_ERROR,
"Failed to initialize glamor\n");
@@ -130,6 +139,8 @@ intel_glamor_init(ScreenPtr screen)
intel->uxa_driver->flags |= UXA_USE_GLAMOR;
intel->uxa_flags = intel->uxa_driver->flags;
+ intel->uxa_driver->need_flush = intel_glamor_need_flush;
+
xf86DrvMsg(scrn->scrnIndex, X_INFO,
"Use GLAMOR acceleration.\n");
return TRUE;
diff --git a/src/intel_uxa.c b/src/intel_uxa.c
index 5202076..9fa0165 100644
--- a/src/intel_uxa.c
+++ b/src/intel_uxa.c
@@ -705,8 +705,14 @@ static Bool intel_uxa_prepare_access(PixmapPtr pixmap, uxa_access_t access)
int ret;
if (!list_is_empty(&priv->batch) &&
- (access == UXA_ACCESS_RW || priv->batch_write))
+ ((access == UXA_ACCESS_RW || access == UXA_GLAMOR_ACCESS_RW)
+ || priv->batch_write))
intel_batch_submit(scrn);
+
+ if (access == UXA_GLAMOR_ACCESS_RW || access == UXA_GLAMOR_ACCESS_RO)
+ return TRUE;
+
+ intel_glamor_block_handler(intel);
if (priv->tiling || bo->size <= intel->max_gtt_map_size)
ret = drm_intel_gem_bo_map_gtt(bo);
diff --git a/uxa/uxa-accel.c b/uxa/uxa-accel.c
index 5b27aaa..bd9e02b 100644
--- a/uxa/uxa-accel.c
+++ b/uxa/uxa-accel.c
@@ -56,11 +56,16 @@ uxa_fill_spans(DrawablePtr pDrawable, GCPtr pGC, int n,
int x1, x2, y;
int off_x, off_y;
- if ((uxa_screen->info->flags & UXA_GLAMOR_FLAGS)
- && (glamor_fill_spans_nf(pDrawable, pGC, n, ppt, pwidth, fSorted)))
- return;
- else if(uxa_screen->info->flags & UXA_USE_GLAMOR_ONLY)
- goto fallback;
+ if ((uxa_screen->info->flags & UXA_GLAMOR_FLAGS)) {
+ uxa_prepare_access(pDrawable, UXA_GLAMOR_ACCESS_RW);
+ if (glamor_fill_spans_nf(pDrawable,
+ pGC, n, ppt, pwidth, fSorted)) {
+ uxa_screen->info->need_flush(pDrawable);
+ glamor_block_handler(screen);
+ return;
+ } else if (uxa_screen->info->flags & UXA_USE_GLAMOR_ONLY)
+ goto fallback;
+ }
if (uxa_screen->swappedOut || uxa_screen->force_fallback)
goto fallback;
@@ -685,9 +690,22 @@ uxa_poly_fill_rect(DrawablePtr pDrawable,
int n;
RegionPtr pReg = RECTS_TO_REGION(pScreen, nrect, prect, CT_UNSORTED);
+ if ((uxa_screen->info->flags & UXA_GLAMOR_FLAGS)) {
+ uxa_prepare_access(pDrawable, UXA_GLAMOR_ACCESS_RW);
+ if (glamor_poly_fill_rect_nf(pDrawable,
+ pGC, nrect, prect)) {
+ uxa_screen->info->need_flush(pDrawable);
+ glamor_block_handler(pDrawable->pScreen);
+ return;
+ } else if (uxa_screen->info->flags & UXA_USE_GLAMOR_ONLY)
+ goto fallback;
+ }
+
if ((uxa_screen->info->flags & UXA_GLAMOR_FLAGS)
- && (glamor_poly_fill_rect_nf(pDrawable, pGC, nrect, prect)))
+ && (glamor_poly_fill_rect_nf(pDrawable, pGC, nrect, prect))) {
+ uxa_screen->info->need_flush(pDrawable);
return;
+ }
else if(uxa_screen->info->flags & UXA_USE_GLAMOR_ONLY)
goto fallback;
diff --git a/uxa/uxa.h b/uxa/uxa.h
index 21e6f2a..5230407 100644
--- a/uxa/uxa.h
+++ b/uxa/uxa.h
@@ -45,7 +45,9 @@
typedef enum {
UXA_ACCESS_RO,
- UXA_ACCESS_RW
+ UXA_ACCESS_RW,
+ UXA_GLAMOR_ACCESS_RO,
+ UXA_GLAMOR_ACCESS_RW
} uxa_access_t;
/**
@@ -530,6 +532,18 @@ typedef struct _UxaDriver {
*/
Bool(*pixmap_is_offscreen) (PixmapPtr pPix);
+ /**
+ * need_flush() is called after Glamor modify a textured pixmap.
+ *
+ * @param pDrawable the target drawable.
+ *
+ *
+ * need_flush is used to notify the underlying DDX layer that
+ * some pixmaps get dirty in glamor access. Thus a render cache
+ * flushing may be required, especially when the modified pixmap
+ * is the screen pixmap which is the front buffer.
+ */
+ void (*need_flush) (DrawablePtr pDrawable);
/** @} */
} uxa_driver_t;
--
1.7.4.4
^ permalink raw reply related [flat|nested] 6+ messages in thread* Re: [PATCH 2/2] glamor: Address GLAMOR/UXA flushing problem.
2011-11-15 11:36 ` [PATCH 2/2] glamor: Address GLAMOR/UXA flushing problem Zhigang Gong
@ 2011-11-15 12:24 ` Chris Wilson
2011-11-15 12:54 ` Zhigang Gong
0 siblings, 1 reply; 6+ messages in thread
From: Chris Wilson @ 2011-11-15 12:24 UTC (permalink / raw)
To: Zhigang Gong, intel-gfx
On Tue, 15 Nov 2011 19:36:14 +0800, Zhigang Gong <zhigang.gong@linux.intel.com> wrote:
> This commit introduces a new function in UXA layer need_flush
> which is used to let the UXA layer to notify the lower layer
> that some pixmap get modified by GLAMOR. And then the intel
> driver could know it need to flush front buffer latter.
>
> This commit also adds some necessary flushing pointis for UXA
> layer and glamor layer. Basicly, there are three scenarios:
>
> 1. Before calling into glamor layer, it needs to flush all the
> corresponding UXA batch comand buffer.
>
> 2. After calling the glamor rendering functions, it needs to
> flush the pending GL operations.
>
> 3. Before we map a pixmap's BO, we also need to flush all the
> pending GL operations.
>
> The scenario 2 could be eliminated when we fully change to glamor
> path.
I much prefer the one-sided uxa_prepare_access() you have implemented
here for the glamor side. For completeness, you still probably want the
uxa_finish_access() though. Alternatively you need to mark up all
operations with uxa_prepare_access(GLAMOR | NATIVE | SW, READ | WRITE)
which then perform the implicit uxa_finish_access() when the mode
changes, and would also allow you to only flush the glamor operations as
required.
Aside from that, this looks like the right approach to handling the
flushing.
-Chris
--
Chris Wilson, Intel Open Source Technology Centre
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 2/2] glamor: Address GLAMOR/UXA flushing problem.
2011-11-15 12:24 ` Chris Wilson
@ 2011-11-15 12:54 ` Zhigang Gong
2011-11-15 12:57 ` Chris Wilson
0 siblings, 1 reply; 6+ messages in thread
From: Zhigang Gong @ 2011-11-15 12:54 UTC (permalink / raw)
To: 'Chris Wilson', intel-gfx
> -----Original Message-----
> From: Chris Wilson [mailto:chris@chris-wilson.co.uk]
> Sent: Tuesday, November 15, 2011 8:25 PM
> To: Zhigang Gong; intel-gfx@lists.freedesktop.org
> Cc: zhigang.gong@linux.intel.com
> Subject: Re: [PATCH 2/2] glamor: Address GLAMOR/UXA flushing problem.
>
> On Tue, 15 Nov 2011 19:36:14 +0800, Zhigang Gong
> <zhigang.gong@linux.intel.com> wrote:
> > This commit introduces a new function in UXA layer need_flush which is
> > used to let the UXA layer to notify the lower layer that some pixmap
> > get modified by GLAMOR. And then the intel driver could know it need
> > to flush front buffer latter.
> >
> > This commit also adds some necessary flushing pointis for UXA layer
> > and glamor layer. Basicly, there are three scenarios:
> >
> > 1. Before calling into glamor layer, it needs to flush all the
> > corresponding UXA batch comand buffer.
> >
> > 2. After calling the glamor rendering functions, it needs to flush the
> > pending GL operations.
> >
> > 3. Before we map a pixmap's BO, we also need to flush all the pending
> > GL operations.
> >
> > The scenario 2 could be eliminated when we fully change to glamor
> > path.
>
> I much prefer the one-sided uxa_prepare_access() you have implemented
> here for the glamor side. For completeness, you still probably want the
> uxa_finish_access() though.
I was thinking about that, but current uxa_finish_access doesn't have a
parameter
to indicate the access type. I prefer to change the uxa_finish_access's
prototype
to the same as uxa_prepare_access(). And then will do glamor flush there if
the
access type is GLAMOR_WRITE. I'm just not very sure whether it is the best
way.
Will work out a new patch to implement that soon.
BTW, May I have your review tag in the commits which get reviewed by you.
Thanks.
> Alternatively you need to mark up all
> operations with uxa_prepare_access(GLAMOR | NATIVE | SW, READ |
> WRITE) which then perform the implicit uxa_finish_access() when the
> mode changes, and would also allow you to only flush the glamor
> operations as required.
This looks much complicate than the first solution. I prefer the first
solution.
-- Zhigang
>
> Aside from that, this looks like the right approach to handling the
flushing.
> -Chris
>
> --
> Chris Wilson, Intel Open Source Technology Centre
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 2/2] glamor: Address GLAMOR/UXA flushing problem.
2011-11-15 12:54 ` Zhigang Gong
@ 2011-11-15 12:57 ` Chris Wilson
0 siblings, 0 replies; 6+ messages in thread
From: Chris Wilson @ 2011-11-15 12:57 UTC (permalink / raw)
To: Zhigang Gong, intel-gfx
On Tue, 15 Nov 2011 20:54:13 +0800, "Zhigang Gong" <zhigang.gong@linux.intel.com> wrote:
> BTW, May I have your review tag in the commits which get reviewed by you.
> Thanks.
I'm hoping that you will rebase the series into something that can be
cleanly merged - i.e. I don't expect the patches in their current form
and order to be applied. ;-)
-Chris
--
Chris Wilson, Intel Open Source Technology Centre
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH 1/2] glamor: Move flags check to intel_glamor.
2011-11-15 11:36 [PATCH 1/2] glamor: Move flags check to intel_glamor Zhigang Gong
2011-11-15 11:36 ` [PATCH 2/2] glamor: Address GLAMOR/UXA flushing problem Zhigang Gong
@ 2011-11-15 12:10 ` Chris Wilson
1 sibling, 0 replies; 6+ messages in thread
From: Chris Wilson @ 2011-11-15 12:10 UTC (permalink / raw)
To: Zhigang Gong, intel-gfx
On Tue, 15 Nov 2011 19:36:13 +0800, Zhigang Gong <zhigang.gong@linux.intel.com> wrote:
> Address Chris comment. We concentrate all the flag check into
> intel_glamor layer which makes the interface to glamor
> self-contained.
Thanks, that looks a lot better and makes it much easier to read how
glamor is integrated into the driver.
-Chris
>
--
Chris Wilson, Intel Open Source Technology Centre
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2011-11-15 12:57 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2011-11-15 11:36 [PATCH 1/2] glamor: Move flags check to intel_glamor Zhigang Gong
2011-11-15 11:36 ` [PATCH 2/2] glamor: Address GLAMOR/UXA flushing problem Zhigang Gong
2011-11-15 12:24 ` Chris Wilson
2011-11-15 12:54 ` Zhigang Gong
2011-11-15 12:57 ` Chris Wilson
2011-11-15 12:10 ` [PATCH 1/2] glamor: Move flags check to intel_glamor Chris Wilson
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox