From: Michel Dänzer <michel.daen...@amd.com>
They can choose between using the GPU or CPU for the operation.
Signed-off-by: Michel Dänzer <michel.daen...@amd.com>
---
src/Makefile.am | 1 +
src/radeon.h | 30 ++
src/radeon_glamor.h | 1 +
src/radeon_glamor_wrappers.c | 985 +++++++++++++++++++++++++++++++++++++++++++
src/radeon_kms.c | 1 +
5 files changed, 1018 insertions(+)
create mode 100644 src/radeon_glamor_wrappers.c
diff --git a/src/Makefile.am b/src/Makefile.am
index 697c08c..a5c4bc2 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -65,6 +65,7 @@ if GLAMOR
AM_CFLAGS += @LIBGLAMOR_CFLAGS@
radeon_drv_la_LIBADD += @LIBGLAMOR_LIBS@
radeon_drv_la_SOURCES += \
+ radeon_glamor_wrappers.c \
radeon_glamor.c
endif
diff --git a/src/radeon.h b/src/radeon.h
index 83b462b..80adc5d 100644
--- a/src/radeon.h
+++ b/src/radeon.h
@@ -248,6 +248,10 @@ typedef enum {
struct radeon_pixmap {
struct radeon_surface surface;
+
+ uint_fast32_t gpu_read;
+ uint_fast32_t gpu_write;
+
struct radeon_bo *bo;
uint32_t tiling_flags;
@@ -467,6 +471,8 @@ typedef struct {
Bool RenderAccel; /* Render */
Bool allowColorTiling;
Bool allowColorTiling2D;
+ uint_fast32_t gpu_flushed;
+ uint_fast32_t gpu_synced;
struct radeon_accel_state *accel_state;
Bool accelOn;
Bool use_glamor;
@@ -525,6 +531,30 @@ typedef struct {
/* cursor size */
int cursor_w;
int cursor_h;
+
+#ifdef USE_GLAMOR
+ struct {
+ CreateGCProcPtr SavedCreateGC;
+ RegionPtr (*SavedCopyArea)(DrawablePtr, DrawablePtr, GCPtr, int, int,
+ int, int, int, int);
+ CloseScreenProcPtr SavedCloseScreen;
+ GetImageProcPtr SavedGetImage;
+ GetSpansProcPtr SavedGetSpans;
+ CreatePixmapProcPtr SavedCreatePixmap;
+ DestroyPixmapProcPtr SavedDestroyPixmap;
+ CopyWindowProcPtr SavedCopyWindow;
+ ChangeWindowAttributesProcPtr SavedChangeWindowAttributes;
+ BitmapToRegionProcPtr SavedBitmapToRegion;
+#ifdef RENDER
+ CompositeProcPtr SavedComposite;
+ TrianglesProcPtr SavedTriangles;
+ GlyphsProcPtr SavedGlyphs;
+ TrapezoidsProcPtr SavedTrapezoids;
+ AddTrapsProcPtr SavedAddTraps;
+ UnrealizeGlyphProcPtr SavedUnrealizeGlyph;
+#endif
+ } glamor;
+#endif /* USE_GLAMOR */
} RADEONInfoRec, *RADEONInfoPtr;
/* radeon_accel.c */
diff --git a/src/radeon_glamor.h b/src/radeon_glamor.h
index 8010b4a..ea385c7 100644
--- a/src/radeon_glamor.h
+++ b/src/radeon_glamor.h
@@ -55,6 +55,7 @@ struct radeon_pixmap;
Bool radeon_glamor_pre_init(ScrnInfoPtr scrn);
Bool radeon_glamor_init(ScreenPtr screen);
+void radeon_glamor_screen_init(ScreenPtr screen);
Bool radeon_glamor_create_screen_resources(ScreenPtr screen);
void radeon_glamor_free_screen(int scrnIndex, int flags);
diff --git a/src/radeon_glamor_wrappers.c b/src/radeon_glamor_wrappers.c
new file mode 100644
index 0000000..db2e85f
--- /dev/null
+++ b/src/radeon_glamor_wrappers.c
@@ -0,0 +1,985 @@
+/*
+ * Copyright � 2001 Keith Packard
+ * 2010 Intel Corporation
+ * 2012,2015 Advanced Micro Devices, Inc.
+ *
+ * Partly based on code Copyright � 2008 Red Hat, Inc.
+ * Partly based on code Copyright � 2000 SuSE, Inc.
+ *
+ * Partly based on code that is Copyright � The XFree86 Project Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of the opyright holders not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. The copyright holders make no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef USE_GLAMOR
+
+#include "radeon.h"
+#include "radeon_glamor.h"
+
+
+/**
+ * get_drawable_pixmap() returns the backing pixmap for a given drawable.
+ *
+ * @param pDrawable the drawable being requested.
+ *
+ * This function returns the backing pixmap for a drawable, whether it is a
+ * redirected window, unredirected window, or already a pixmap.
+ */
+static PixmapPtr
+get_drawable_pixmap(DrawablePtr pDrawable)
+{
+ if (pDrawable->type == DRAWABLE_WINDOW)
+ return pDrawable->pScreen->
+ GetWindowPixmap((WindowPtr) pDrawable);
+ else
+ return (PixmapPtr) pDrawable;
+}
+
+/* Are there any outstanding GPU operations for this pixmap? */
+static Bool
+radeon_glamor_gpu_pending(uint_fast32_t gpu_synced, uint_fast32_t gpu_access)
+{
+ return (int_fast32_t)(gpu_access - gpu_synced) > 0;
+}
+
+/*
+ * Pixmap CPU access wrappers
+ */
+
+static Bool
+radeon_glamor_prepare_access_cpu(ScrnInfoPtr scrn, RADEONInfoPtr info,
+ PixmapPtr pixmap, struct radeon_pixmap *priv,
+ Bool need_sync)
+{
+ struct radeon_bo *bo = priv->bo;
+ int ret;
+
+ /* When falling back to swrast, flush all pending operations */
+ if (need_sync) {
+ glamor_block_handler(scrn->pScreen);
+ info->gpu_flushed++;
+ }
+
+ if (!pixmap->devPrivate.ptr) {
+ ret = radeon_bo_map(bo, 1);
+ if (ret) {
+ xf86DrvMsg(scrn->scrnIndex, X_WARNING,
+ "%s: bo map (tiling_flags %d) failed: %s\n",
+ __FUNCTION__,
+ priv->tiling_flags,
+ strerror(-ret));
+ return FALSE;
+ }
+
+ pixmap->devPrivate.ptr = bo->ptr;
+ info->gpu_synced = info->gpu_flushed;
+ } else if (need_sync) {
+ radeon_bo_wait(bo);
+ info->gpu_synced = info->gpu_flushed;
+ }
+
+ return TRUE;
+}
+
+static Bool
+radeon_glamor_prepare_access_cpu_ro(ScrnInfoPtr scrn, PixmapPtr pixmap,
+ struct radeon_pixmap *priv)
+{
+ RADEONInfoPtr info;
+ Bool need_sync;
+
+ if (!priv)
+ return TRUE;
+
+ info = RADEONPTR(scrn);
+ need_sync = radeon_glamor_gpu_pending(info->gpu_synced, priv->gpu_read);
+ return radeon_glamor_prepare_access_cpu(scrn, RADEONPTR(scrn), pixmap,
+ priv, need_sync);
+}
+
+static Bool
+radeon_glamor_prepare_access_cpu_rw(ScrnInfoPtr scrn, PixmapPtr pixmap,
+ struct radeon_pixmap *priv)
+{
+ RADEONInfoPtr info;
+ uint_fast32_t gpu_synced;
+ Bool need_sync;
+
+ if (!priv)
+ return TRUE;
+
+ info = RADEONPTR(scrn);
+ gpu_synced = info->gpu_synced;
+ need_sync = radeon_glamor_gpu_pending(gpu_synced, priv->gpu_write) |
+ radeon_glamor_gpu_pending(gpu_synced, priv->gpu_read);
+ return radeon_glamor_prepare_access_cpu(scrn, info, pixmap, priv,
+ need_sync);
+}
+
+static void
+radeon_glamor_finish_access_cpu(PixmapPtr pixmap)
+{
+ /* Nothing to do */
+}
+
+/*
+ * Pixmap GPU access wrappers
+ */
+
+static Bool
+radeon_glamor_prepare_access_gpu(struct radeon_pixmap *priv)
+{
+ return priv != NULL;
+}
+
+static void
+radeon_glamor_finish_access_gpu_ro(RADEONInfoPtr info,
+ struct radeon_pixmap *priv)
+{
+ priv->gpu_read = info->gpu_flushed + 1;
+}
+
+static void
+radeon_glamor_finish_access_gpu_rw(RADEONInfoPtr info,
+ struct radeon_pixmap *priv)
+{
+ priv->gpu_write = priv->gpu_read = info->gpu_flushed + 1;
+}
+
+/*
+ * GC CPU access wrappers
+ */
+
+static Bool
+radeon_glamor_prepare_access_gc(ScrnInfoPtr scrn, GCPtr pGC)
+{
+ struct radeon_pixmap *priv;
+
+ if (pGC->stipple) {
+ priv = radeon_get_pixmap_private(pGC->stipple);
+ if (!radeon_glamor_prepare_access_cpu_ro(scrn, pGC->stipple,
priv))
+ return FALSE;
+ }
+ if (pGC->fillStyle == FillTiled) {
+ priv = radeon_get_pixmap_private(pGC->tile.pixmap);
+ if (!radeon_glamor_prepare_access_cpu_ro(scrn, pGC->tile.pixmap,
+ priv)) {
+ if (pGC->stipple)
+ radeon_glamor_finish_access_cpu(pGC->stipple);
+ return FALSE;
+ }
+ }
+ return TRUE;
+}
+
+static void
+radeon_glamor_finish_access_gc(GCPtr pGC)
+{
+ if (pGC->fillStyle == FillTiled)
+ radeon_glamor_finish_access_cpu(pGC->tile.pixmap);
+ if (pGC->stipple)
+ radeon_glamor_finish_access_cpu(pGC->stipple);
+}
+
+/*
+ * Picture CPU access wrappers
+ */
+
+static void
+radeon_glamor_picture_finish_access_cpu(PicturePtr picture)
+{
+ /* Nothing to do */
+}
+
+static Bool
+radeon_glamor_picture_prepare_access_cpu_ro(ScrnInfoPtr scrn,
+ PicturePtr picture)
+{
+ PixmapPtr pixmap;
+ struct radeon_pixmap *priv;
+
+ if (picture->pDrawable == NULL)
+ return TRUE;
+
+ pixmap = get_drawable_pixmap(picture->pDrawable);
+ priv = radeon_get_pixmap_private(pixmap);
+ if (!radeon_glamor_prepare_access_cpu_ro(scrn, pixmap, priv))
+ return FALSE;
+
+ if (picture->alphaMap) {
+ pixmap = get_drawable_pixmap(picture->alphaMap->pDrawable);
+ priv = radeon_get_pixmap_private(pixmap);
+ if (!radeon_glamor_prepare_access_cpu_ro(scrn, pixmap, priv)) {
+ radeon_glamor_picture_finish_access_cpu(picture);
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+static Bool
+radeon_glamor_picture_prepare_access_cpu_rw(ScrnInfoPtr scrn,
+ PicturePtr picture)
+{
+ PixmapPtr pixmap;
+ struct radeon_pixmap *priv;
+
+ pixmap = get_drawable_pixmap(picture->pDrawable);
+ priv = radeon_get_pixmap_private(pixmap);
+ if (!radeon_glamor_prepare_access_cpu_rw(scrn, pixmap, priv))
+ return FALSE;
+
+ if (picture->alphaMap) {
+ pixmap = get_drawable_pixmap(picture->alphaMap->pDrawable);
+ priv = radeon_get_pixmap_private(pixmap);
+ if (!radeon_glamor_prepare_access_cpu_rw(scrn, pixmap, priv)) {
+ radeon_glamor_picture_finish_access_cpu(picture);
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+/*
+ * GC rendering wrappers
+ */
+
+static void
+radeon_glamor_fill_spans(DrawablePtr pDrawable, GCPtr pGC, int nspans,
+ DDXPointPtr ppt, int *pwidth, int fSorted)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDrawable->pScreen);
+ PixmapPtr pixmap = get_drawable_pixmap(pDrawable);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pixmap);
+
+ if (radeon_glamor_prepare_access_cpu_rw(scrn, pixmap, priv)) {
+ if (radeon_glamor_prepare_access_gc(scrn, pGC)) {
+ fbFillSpans(pDrawable, pGC, nspans, ppt, pwidth,
+ fSorted);
+ radeon_glamor_finish_access_gc(pGC);
+ }
+ radeon_glamor_finish_access_cpu(pixmap);
+ }
+}
+
+static void
+radeon_glamor_set_spans(DrawablePtr pDrawable, GCPtr pGC, char *psrc,
+ DDXPointPtr ppt, int *pwidth, int nspans, int fSorted)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDrawable->pScreen);
+ PixmapPtr pixmap = get_drawable_pixmap(pDrawable);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pixmap);
+
+ if (radeon_glamor_prepare_access_cpu_rw(scrn, pixmap, priv)) {
+ fbSetSpans(pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted);
+ radeon_glamor_finish_access_cpu(pixmap);
+ }
+}
+
+static void
+radeon_glamor_put_image(DrawablePtr pDrawable, GCPtr pGC, int depth,
+ int x, int y, int w, int h, int leftPad, int format,
+ char *bits)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDrawable->pScreen);
+ PixmapPtr pixmap = get_drawable_pixmap(pDrawable);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pixmap);
+
+ if (radeon_glamor_prepare_access_cpu_rw(scrn, pixmap, priv)) {
+ fbPutImage(pDrawable, pGC, depth, x, y, w, h, leftPad, format,
+ bits);
+ radeon_glamor_finish_access_cpu(pixmap);
+ }
+}
+
+static RegionPtr
+radeon_glamor_copy_plane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+ int srcx, int srcy, int w, int h, int dstx, int dsty,
+ unsigned long bitPlane)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDst->pScreen);
+ PixmapPtr dst_pix = get_drawable_pixmap(pDst);
+ struct radeon_pixmap *dst_priv = radeon_get_pixmap_private(dst_pix);
+ RegionPtr ret = NULL;
+
+ if (radeon_glamor_prepare_access_cpu_rw(scrn, dst_pix, dst_priv)) {
+ PixmapPtr src_pix = get_drawable_pixmap(pSrc);
+ struct radeon_pixmap *src_priv =
radeon_get_pixmap_private(src_pix);
+ if (radeon_glamor_prepare_access_cpu_ro(scrn, src_pix,
src_priv)) {
+ ret =
+ fbCopyPlane(pSrc, pDst, pGC, srcx, srcy, w, h, dstx,
+ dsty, bitPlane);
+ radeon_glamor_finish_access_cpu(src_pix);
+ }
+ radeon_glamor_finish_access_cpu(dst_pix);
+ }
+ return ret;
+}
+
+static RegionPtr
+radeon_glamor_copy_plane_nodstbo(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
+ int srcx, int srcy, int w, int h,
+ int dstx, int dsty, unsigned long bitPlane)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDst->pScreen);
+ PixmapPtr src_pix = get_drawable_pixmap(pSrc);
+ struct radeon_pixmap *src_priv = radeon_get_pixmap_private(src_pix);
+ RegionPtr ret = NULL;
+
+ if (radeon_glamor_prepare_access_cpu_ro(scrn, src_pix, src_priv)) {
+ ret = fbCopyPlane(pSrc, pDst, pGC, srcx, srcy, w, h,
+ dstx, dsty, bitPlane);
+ radeon_glamor_finish_access_cpu(src_pix);
+ }
+ return ret;
+}
+
+static void
+radeon_glamor_poly_point(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
+ DDXPointPtr pptInit)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDrawable->pScreen);
+ PixmapPtr pixmap = get_drawable_pixmap(pDrawable);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pixmap);
+
+ if (radeon_glamor_prepare_access_cpu_rw(scrn, pixmap, priv)) {
+ fbPolyPoint(pDrawable, pGC, mode, npt, pptInit);
+ radeon_glamor_finish_access_cpu(pixmap);
+ }
+}
+
+static void
+radeon_glamor_poly_lines(DrawablePtr pDrawable, GCPtr pGC,
+ int mode, int npt, DDXPointPtr ppt)
+{
+ if (pGC->lineWidth == 0) {
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDrawable->pScreen);
+ PixmapPtr pixmap = get_drawable_pixmap(pDrawable);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pixmap);
+
+ if (radeon_glamor_prepare_access_cpu_rw(scrn, pixmap, priv)) {
+ if (radeon_glamor_prepare_access_gc(scrn, pGC)) {
+ fbPolyLine(pDrawable, pGC, mode, npt, ppt);
+ radeon_glamor_finish_access_gc(pGC);
+ }
+ radeon_glamor_finish_access_cpu(pixmap);
+ }
+ return;
+ }
+ /* fb calls mi functions in the lineWidth != 0 case. */
+ fbPolyLine(pDrawable, pGC, mode, npt, ppt);
+}
+
+static void
+radeon_glamor_poly_segment(DrawablePtr pDrawable, GCPtr pGC,
+ int nsegInit, xSegment *pSegInit)
+{
+ if (pGC->lineWidth == 0) {
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDrawable->pScreen);
+ PixmapPtr pixmap = get_drawable_pixmap(pDrawable);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pixmap);
+
+ if (radeon_glamor_prepare_access_cpu_rw(scrn, pixmap, priv)) {
+ if (radeon_glamor_prepare_access_gc(scrn, pGC)) {
+ fbPolySegment(pDrawable, pGC, nsegInit,
+ pSegInit);
+ radeon_glamor_finish_access_gc(pGC);
+ }
+ radeon_glamor_finish_access_cpu(pixmap);
+ }
+ return;
+ }
+ /* fb calls mi functions in the lineWidth != 0 case. */
+ fbPolySegment(pDrawable, pGC, nsegInit, pSegInit);
+}
+
+static void
+radeon_glamor_poly_fill_rect(DrawablePtr pDrawable, GCPtr pGC,
+ int nrect, xRectangle *prect)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDrawable->pScreen);
+ PixmapPtr pixmap = get_drawable_pixmap(pDrawable);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pixmap);
+
+ if (radeon_glamor_prepare_access_cpu_rw(scrn, pixmap, priv)) {
+ if (radeon_glamor_prepare_access_gc(scrn, pGC)) {
+ fbPolyFillRect(pDrawable, pGC, nrect, prect);
+ radeon_glamor_finish_access_gc(pGC);
+ }
+ radeon_glamor_finish_access_cpu(pixmap);
+ }
+}
+
+static void
+radeon_glamor_image_glyph_blt(DrawablePtr pDrawable, GCPtr pGC,
+ int x, int y, unsigned int nglyph,
+ CharInfoPtr *ppci, pointer pglyphBase)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDrawable->pScreen);
+ PixmapPtr pixmap = get_drawable_pixmap(pDrawable);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pixmap);
+
+ if (radeon_glamor_prepare_access_cpu_rw(scrn, pixmap, priv)) {
+ if (radeon_glamor_prepare_access_gc(scrn, pGC)) {
+ fbImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci,
+ pglyphBase);
+ radeon_glamor_finish_access_gc(pGC);
+ }
+ radeon_glamor_finish_access_cpu(pixmap);
+ }
+}
+
+static void
+radeon_glamor_poly_glyph_blt(DrawablePtr pDrawable, GCPtr pGC,
+ int x, int y, unsigned int nglyph,
+ CharInfoPtr *ppci, pointer pglyphBase)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDrawable->pScreen);
+ PixmapPtr pixmap = get_drawable_pixmap(pDrawable);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pixmap);
+
+ if (radeon_glamor_prepare_access_cpu_rw(scrn, pixmap, priv)) {
+ if (radeon_glamor_prepare_access_gc(scrn, pGC)) {
+ fbPolyGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci,
+ pglyphBase);
+ radeon_glamor_finish_access_gc(pGC);
+ }
+ radeon_glamor_finish_access_cpu(pixmap);
+ }
+}
+
+static void
+radeon_glamor_push_pixels(GCPtr pGC, PixmapPtr pBitmap,
+ DrawablePtr pDrawable, int w, int h, int x, int y)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDrawable->pScreen);
+ PixmapPtr pixmap = get_drawable_pixmap(pDrawable);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pixmap);
+
+ if (radeon_glamor_prepare_access_cpu_rw(scrn, pixmap, priv)) {
+ priv = radeon_get_pixmap_private(pBitmap);
+ if (radeon_glamor_prepare_access_cpu_ro(scrn, pBitmap, priv)) {
+ if (radeon_glamor_prepare_access_gc(scrn, pGC)) {
+ fbPushPixels(pGC, pBitmap, pDrawable, w, h, x,
+ y);
+ radeon_glamor_finish_access_gc(pGC);
+ }
+ radeon_glamor_finish_access_cpu(pBitmap);
+ }
+ radeon_glamor_finish_access_cpu(pixmap);
+ }
+}
+
+static void
+radeon_glamor_push_pixels_nodstbo(GCPtr pGC, PixmapPtr pBitmap,
+ DrawablePtr pDrawable, int w, int h,
+ int x, int y)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDrawable->pScreen);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pBitmap);
+
+ if (radeon_glamor_prepare_access_cpu_ro(scrn, pBitmap, priv)) {
+ fbPushPixels(pGC, pBitmap, pDrawable, w, h, x, y);
+ radeon_glamor_finish_access_cpu(pBitmap);
+ }
+}
+
+static RegionPtr
+radeon_glamor_copy_area(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
+ GCPtr pGC, int srcx, int srcy, int width, int height,
+ int dstx, int dsty)
+{
+ ScreenPtr screen = pDstDrawable->pScreen;
+ ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
+ RADEONInfoPtr info = RADEONPTR(scrn);
+ PixmapPtr src_pixmap = get_drawable_pixmap(pSrcDrawable);
+ PixmapPtr dst_pixmap = get_drawable_pixmap(pDstDrawable);
+ struct radeon_pixmap *src_priv = radeon_get_pixmap_private(src_pixmap);
+ struct radeon_pixmap *dst_priv = radeon_get_pixmap_private(dst_pixmap);
+ RegionPtr ret = NULL;
+
+ if (info->accel_state->force || (src_priv && !src_priv->bo) ||
+ (dst_priv && !dst_priv->bo)) {
+ if (!radeon_glamor_prepare_access_gpu(dst_priv))
+ goto fallback;
+ if (src_priv != dst_priv &&
+ !radeon_glamor_prepare_access_gpu(src_priv))
+ goto fallback;
+
+ ret = info->glamor.SavedCopyArea(pSrcDrawable, pDstDrawable,
+ pGC, srcx, srcy,
+ width, height, dstx, dsty);
+ radeon_glamor_finish_access_gpu_rw(info, dst_priv);
+ if (src_priv != dst_priv)
+ radeon_glamor_finish_access_gpu_ro(info, src_priv);
+
+ return ret;
+ }
+
+fallback:
+ if (radeon_glamor_prepare_access_cpu_rw(scrn, dst_pixmap, dst_priv)) {
+ if (pSrcDrawable == pDstDrawable ||
+ radeon_glamor_prepare_access_cpu_ro(scrn, src_pixmap,
+ src_priv)) {
+ ret = fbCopyArea(pSrcDrawable, pDstDrawable, pGC,
+ srcx, srcy, width, height, dstx, dsty);
+ if (pSrcDrawable != pDstDrawable)
+ radeon_glamor_finish_access_cpu(src_pixmap);
+ }
+ radeon_glamor_finish_access_cpu(dst_pixmap);
+ }
+
+ return ret;
+}
+
+static RegionPtr
+radeon_glamor_copy_area_nodstbo(DrawablePtr pSrcDrawable,
+ DrawablePtr pDstDrawable, GCPtr pGC,
+ int srcx, int srcy, int width, int height,
+ int dstx, int dsty)
+{
+ ScreenPtr screen = pDstDrawable->pScreen;
+ ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
+ PixmapPtr src_pixmap = get_drawable_pixmap(pSrcDrawable);
+ PixmapPtr dst_pixmap = get_drawable_pixmap(pDstDrawable);
+ struct radeon_pixmap *src_priv;
+ RegionPtr ret = NULL;
+
+ if (src_pixmap != dst_pixmap) {
+ src_priv = radeon_get_pixmap_private(src_pixmap);
+
+ if (!radeon_glamor_prepare_access_cpu_ro(scrn, src_pixmap,
+ src_priv))
+ return ret;
+ }
+
+ ret = fbCopyArea(pSrcDrawable, pDstDrawable, pGC, srcx, srcy,
+ width, height, dstx, dsty);
+
+ if (src_pixmap != dst_pixmap)
+ radeon_glamor_finish_access_cpu(src_pixmap);
+
+ return ret;
+}
+
+static const GCOps radeon_glamor_ops = {
+ radeon_glamor_fill_spans,
+ radeon_glamor_set_spans,
+ radeon_glamor_put_image,
+ radeon_glamor_copy_area,
+ radeon_glamor_copy_plane,
+ radeon_glamor_poly_point,
+ radeon_glamor_poly_lines,
+ radeon_glamor_poly_segment,
+ miPolyRectangle,
+ miPolyArc,
+ miFillPolygon,
+ radeon_glamor_poly_fill_rect,
+ miPolyFillArc,
+ miPolyText8,
+ miPolyText16,
+ miImageText8,
+ miImageText16,
+ radeon_glamor_image_glyph_blt,
+ radeon_glamor_poly_glyph_blt,
+ radeon_glamor_push_pixels,
+};
+
+static GCOps radeon_glamor_nodstbo_ops;
+
+/**
+ * radeon_glamor_validate_gc() sets the ops to our implementations, which may
be
+ * accelerated or may sync the card and fall back to fb.
+ */
+static void
+radeon_glamor_validate_gc(GCPtr pGC, unsigned long changes, DrawablePtr
pDrawable)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pGC->pScreen);
+ RADEONInfoPtr info = RADEONPTR(scrn);
+
+ glamor_validate_gc(pGC, changes, pDrawable);
+ info->glamor.SavedCopyArea = pGC->ops->CopyArea;
+
+ if (radeon_get_pixmap_private(get_drawable_pixmap(pDrawable)) ||
+ (pGC->stipple && radeon_get_pixmap_private(pGC->stipple)) ||
+ (pGC->fillStyle == FillTiled &&
+ radeon_get_pixmap_private(pGC->tile.pixmap)))
+ pGC->ops = (GCOps *)&radeon_glamor_ops;
+ else
+ pGC->ops = &radeon_glamor_nodstbo_ops;
+}
+
+static GCFuncs glamorGCFuncs = {
+ radeon_glamor_validate_gc,
+ miChangeGC,
+ miCopyGC,
+ miDestroyGC,
+ miChangeClip,
+ miDestroyClip,
+ miCopyClip
+};
+
+/**
+ * radeon_glamor_create_gc makes a new GC and hooks up its funcs handler, so
that
+ * radeon_glamor_validate_gc() will get called.
+ */
+static int
+radeon_glamor_create_gc(GCPtr pGC)
+{
+ static Bool nodstbo_ops_initialized;
+
+ if (!fbCreateGC(pGC))
+ return FALSE;
+
+ if (!nodstbo_ops_initialized) {
+ radeon_glamor_nodstbo_ops = radeon_glamor_ops;
+
+ radeon_glamor_nodstbo_ops.FillSpans = pGC->ops->FillSpans;
+ radeon_glamor_nodstbo_ops.SetSpans = pGC->ops->SetSpans;
+ radeon_glamor_nodstbo_ops.PutImage = pGC->ops->PutImage;
+ radeon_glamor_nodstbo_ops.CopyArea =
radeon_glamor_copy_area_nodstbo;
+ radeon_glamor_nodstbo_ops.CopyPlane =
radeon_glamor_copy_plane_nodstbo;
+ radeon_glamor_nodstbo_ops.PolyPoint = pGC->ops->PolyPoint;
+ radeon_glamor_nodstbo_ops.Polylines = pGC->ops->Polylines;
+ radeon_glamor_nodstbo_ops.PolySegment = pGC->ops->PolySegment;
+ radeon_glamor_nodstbo_ops.PolyFillRect = pGC->ops->PolyFillRect;
+ radeon_glamor_nodstbo_ops.ImageGlyphBlt =
pGC->ops->ImageGlyphBlt;
+ radeon_glamor_nodstbo_ops.PolyGlyphBlt = pGC->ops->PolyGlyphBlt;
+ radeon_glamor_nodstbo_ops.PushPixels =
radeon_glamor_push_pixels_nodstbo;
+
+ nodstbo_ops_initialized = TRUE;
+ }
+
+ pGC->funcs = &glamorGCFuncs;
+
+ return TRUE;
+}
+
+/*
+ * Screen rendering wrappers
+ */
+
+static RegionPtr
+radeon_glamor_bitmap_to_region(PixmapPtr pPix)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pPix->drawable.pScreen);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pPix);
+ RegionPtr ret;
+
+ if (!radeon_glamor_prepare_access_cpu_ro(scrn, pPix, priv))
+ return NULL;
+ ret = fbPixmapToRegion(pPix);
+ radeon_glamor_finish_access_cpu(pPix);
+ return ret;
+}
+
+static void
+radeon_glamor_copy_window(WindowPtr pWin, DDXPointRec ptOldOrg,
+ RegionPtr prgnSrc)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pWin->drawable.pScreen);
+ PixmapPtr pixmap = get_drawable_pixmap(&pWin->drawable);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pixmap);
+
+ if (radeon_glamor_prepare_access_cpu_rw(scrn, pixmap, priv)) {
+ fbCopyWindow(pWin, ptOldOrg, prgnSrc);
+ radeon_glamor_finish_access_cpu(pixmap);
+ }
+}
+
+static void
+radeon_glamor_get_image(DrawablePtr pDrawable, int x, int y, int w, int h,
+ unsigned int format, unsigned long planeMask, char *d)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDrawable->pScreen);
+ PixmapPtr pixmap = get_drawable_pixmap(pDrawable);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pixmap);
+
+ if (radeon_glamor_prepare_access_cpu_ro(scrn, pixmap, priv)) {
+ fbGetImage(pDrawable, x, y, w, h, format, planeMask, d);
+ radeon_glamor_finish_access_cpu(pixmap);
+ }
+}
+
+static void
+radeon_glamor_get_spans(DrawablePtr pDrawable, int wMax, DDXPointPtr ppt,
+ int *pwidth, int nspans, char *pdstStart)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDrawable->pScreen);
+ PixmapPtr pixmap = get_drawable_pixmap(pDrawable);
+ struct radeon_pixmap *priv = radeon_get_pixmap_private(pixmap);
+
+ if (radeon_glamor_prepare_access_cpu_ro(scrn, pixmap, priv)) {
+ fbGetSpans(pDrawable, wMax, ppt, pwidth, nspans, pdstStart);
+ radeon_glamor_finish_access_cpu(pixmap);
+ }
+}
+
+/*
+ * Picture screen rendering wrappers
+ */
+
+#ifdef RENDER
+
+static void
+radeon_glamor_composite(CARD8 op,
+ PicturePtr pSrc,
+ PicturePtr pMask,
+ PicturePtr pDst,
+ INT16 xSrc, INT16 ySrc,
+ INT16 xMask, INT16 yMask,
+ INT16 xDst, INT16 yDst,
+ CARD16 width, CARD16 height)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pDst->pDrawable->pScreen);
+ RADEONInfoPtr info;
+ PixmapPtr pixmap;
+ struct radeon_pixmap *dst_priv, *src_priv = NULL, *mask_priv = NULL;
+ Bool gpu_done = FALSE;
+
+ if (pDst->alphaMap || pSrc->alphaMap || (pMask && pMask->alphaMap))
+ goto fallback;
+
+ pixmap = get_drawable_pixmap(pDst->pDrawable);
+ if (&pixmap->drawable != pDst->pDrawable ||
+ pixmap->usage_hint != RADEON_CREATE_PIXMAP_SCANOUT)
+ goto fallback;
+
+ dst_priv = radeon_get_pixmap_private(pixmap);
+ if (!radeon_glamor_prepare_access_gpu(dst_priv))
+ goto fallback;
+
+ info = RADEONPTR(scrn);
+ if (!pSrc->pDrawable ||
+ ((pixmap = get_drawable_pixmap(pSrc->pDrawable)) &&
+ (src_priv = radeon_get_pixmap_private(pixmap)) &&
+ radeon_glamor_prepare_access_gpu(src_priv))) {
+ if (!pMask || !pMask->pDrawable ||
+ ((pixmap = get_drawable_pixmap(pMask->pDrawable)) &&
+ (mask_priv = radeon_get_pixmap_private(pixmap)) &&
+ radeon_glamor_prepare_access_gpu(mask_priv))) {
+ info->glamor.SavedComposite(op, pSrc, pMask, pDst,
+ xSrc, ySrc, xMask, yMask,
+ xDst, yDst, width, height);
+ gpu_done = TRUE;
+
+ if (mask_priv)
+ radeon_glamor_finish_access_gpu_ro(info,
mask_priv);
+ }
+
+ if (src_priv)
+ radeon_glamor_finish_access_gpu_ro(info, src_priv);
+ }
+ radeon_glamor_finish_access_gpu_rw(info, dst_priv);
+
+ if (gpu_done)
+ return;
+
+fallback:
+ if (radeon_glamor_picture_prepare_access_cpu_rw(scrn, pDst)) {
+ if (radeon_glamor_picture_prepare_access_cpu_ro(scrn, pSrc)) {
+ if (!pMask ||
+ radeon_glamor_picture_prepare_access_cpu_ro(scrn,
pMask)) {
+ fbComposite(op, pSrc, pMask, pDst,
+ xSrc, ySrc,
+ xMask, yMask,
+ xDst, yDst,
+ width, height);
+ if (pMask)
+
radeon_glamor_picture_finish_access_cpu(pMask);
+ }
+ radeon_glamor_picture_finish_access_cpu(pSrc);
+ }
+ radeon_glamor_picture_finish_access_cpu(pDst);
+ }
+}
+
+static void
+radeon_glamor_add_traps(PicturePtr pPicture,
+ INT16 x_off, INT16 y_off, int ntrap, xTrap *traps)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(pPicture->pDrawable->pScreen);
+
+ if (radeon_glamor_picture_prepare_access_cpu_rw(scrn, pPicture)) {
+ fbAddTraps(pPicture, x_off, y_off, ntrap, traps);
+ radeon_glamor_picture_finish_access_cpu(pPicture);
+ }
+}
+
+static void
+radeon_glamor_glyphs(CARD8 op,
+ PicturePtr src,
+ PicturePtr dst,
+ PictFormatPtr maskFormat,
+ INT16 xSrc,
+ INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr *glyphs)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(dst->pDrawable->pScreen);
+
+ if (radeon_glamor_picture_prepare_access_cpu_rw(scrn, dst)) {
+ if (radeon_glamor_picture_prepare_access_cpu_ro(scrn, src)) {
+ RADEONInfoPtr info = RADEONPTR(scrn);
+
+ info->glamor.SavedGlyphs(op, src, dst, maskFormat, xSrc,
+ ySrc, nlist, list, glyphs);
+ radeon_glamor_picture_finish_access_cpu(src);
+ }
+ radeon_glamor_picture_finish_access_cpu(dst);
+ }
+}
+
+static void
+radeon_glamor_trapezoids(CARD8 op, PicturePtr src, PicturePtr dst,
+ PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
+ int ntrap, xTrapezoid *traps)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(dst->pDrawable->pScreen);
+
+ if (radeon_glamor_picture_prepare_access_cpu_rw(scrn, dst)) {
+ if (radeon_glamor_picture_prepare_access_cpu_ro(scrn, src)) {
+ RADEONInfoPtr info = RADEONPTR(scrn);
+
+ info->glamor.SavedTrapezoids(op, src, dst, maskFormat,
+ xSrc, ySrc, ntrap, traps);
+ radeon_glamor_picture_finish_access_cpu(src);
+ }
+ radeon_glamor_picture_finish_access_cpu(dst);
+ }
+}
+
+static void
+radeon_glamor_triangles(CARD8 op, PicturePtr src, PicturePtr dst,
+ PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
+ int ntri, xTriangle *tri)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(dst->pDrawable->pScreen);
+
+ if (radeon_glamor_picture_prepare_access_cpu_rw(scrn, dst)) {
+ if (radeon_glamor_picture_prepare_access_cpu_ro(scrn, src)) {
+ RADEONInfoPtr info = RADEONPTR(scrn);
+
+ info->glamor.SavedTriangles(op, src, dst, maskFormat,
+ xSrc, ySrc, ntri, tri);
+ radeon_glamor_picture_finish_access_cpu(src);
+ }
+ radeon_glamor_picture_finish_access_cpu(dst);
+ }
+}
+
+#endif /* RENDER */
+
+
+/**
+ * radeon_glamor_close_screen() unwraps its wrapped screen functions and tears
+ * down our screen private, before calling down to the next CloseScreen.
+ */
+static Bool
+radeon_glamor_close_screen(CLOSE_SCREEN_ARGS_DECL)
+{
+ RADEONInfoPtr info = RADEONPTR(xf86ScreenToScrn(pScreen));
+#ifdef RENDER
+ PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
+#endif
+
+ pScreen->CreateGC = info->glamor.SavedCreateGC;
+ pScreen->CloseScreen = info->glamor.SavedCloseScreen;
+ pScreen->GetImage = info->glamor.SavedGetImage;
+ pScreen->GetSpans = info->glamor.SavedGetSpans;
+ pScreen->CreatePixmap = info->glamor.SavedCreatePixmap;
+ pScreen->DestroyPixmap = info->glamor.SavedDestroyPixmap;
+ pScreen->CopyWindow = info->glamor.SavedCopyWindow;
+ pScreen->ChangeWindowAttributes =
+ info->glamor.SavedChangeWindowAttributes;
+ pScreen->BitmapToRegion = info->glamor.SavedBitmapToRegion;
+#ifdef RENDER
+ if (ps) {
+ ps->Composite = info->glamor.SavedComposite;
+ ps->Glyphs = info->glamor.SavedGlyphs;
+ ps->UnrealizeGlyph = info->glamor.SavedUnrealizeGlyph;
+ ps->Trapezoids = info->glamor.SavedTrapezoids;
+ ps->AddTraps = info->glamor.SavedAddTraps;
+ ps->Triangles = info->glamor.SavedTriangles;
+
+ ps->UnrealizeGlyph = info->glamor.SavedUnrealizeGlyph;
+ }
+#endif
+
+ return (*pScreen->CloseScreen) (CLOSE_SCREEN_ARGS);
+}
+
+/**
+ * @param screen screen being initialized
+ */
+void
+radeon_glamor_screen_init(ScreenPtr screen)
+{
+ RADEONInfoPtr info = RADEONPTR(xf86ScreenToScrn(screen));
+
+ /*
+ * Replace various fb screen functions
+ */
+ info->glamor.SavedCloseScreen = screen->CloseScreen;
+ screen->CloseScreen = radeon_glamor_close_screen;
+
+ info->glamor.SavedCreateGC = screen->CreateGC;
+ screen->CreateGC = radeon_glamor_create_gc;
+
+ info->glamor.SavedGetImage = screen->GetImage;
+ screen->GetImage = radeon_glamor_get_image;
+
+ info->glamor.SavedGetSpans = screen->GetSpans;
+ screen->GetSpans = radeon_glamor_get_spans;
+
+ info->glamor.SavedCreatePixmap = screen->CreatePixmap;
+ info->glamor.SavedDestroyPixmap = screen->DestroyPixmap;
+
+ info->glamor.SavedCopyWindow = screen->CopyWindow;
+ screen->CopyWindow = radeon_glamor_copy_window;
+
+ info->glamor.SavedBitmapToRegion = screen->BitmapToRegion;
+ screen->BitmapToRegion = radeon_glamor_bitmap_to_region;
+
+#ifdef RENDER
+ {
+ PictureScreenPtr ps = GetPictureScreenIfSet(screen);
+ if (ps) {
+ info->glamor.SavedComposite = ps->Composite;
+ ps->Composite = radeon_glamor_composite;
+
+ info->glamor.SavedUnrealizeGlyph = ps->UnrealizeGlyph;
+
+ ps->Glyphs = radeon_glamor_glyphs;
+ ps->Triangles = radeon_glamor_triangles;
+ ps->Trapezoids = radeon_glamor_trapezoids;
+
+ info->glamor.SavedAddTraps = ps->AddTraps;
+ ps->AddTraps = radeon_glamor_add_traps;
+ }
+ }
+#endif
+}
+
+#endif /* USE_GLAMOR */
diff --git a/src/radeon_kms.c b/src/radeon_kms.c
index 0722f0d..3f723d5 100644
--- a/src/radeon_kms.c
+++ b/src/radeon_kms.c
@@ -91,6 +91,7 @@ void radeon_cs_flush_indirect(ScrnInfoPtr pScrn)
#ifdef USE_GLAMOR
if (info->use_glamor) {
glamor_block_handler(pScrn->pScreen);
+ info->gpu_flushed++;
return;
}
#endif
--
2.1.4
_______________________________________________
xorg-driver-ati mailing list
xorg-driver-ati@lists.x.org
http://lists.x.org/mailman/listinfo/xorg-driver-ati
