ec5c2469da
2.9.1 is the last version of the intel DDX that supports UMS (User modesetting), with 2.10 onwards being purely KMS only. As such, this driver contains backports of almost every correctness or performance related fix to the rendering layer in later intel drivers. This driver *REQUIRES* a GEM enabled kernel. it claims to support non-gem mode but this is essentially unmaintained and due to the way the abstraciton works is slow, if it works at all (it often does not). You have been warned. tested by many many people on tech over the last few weeks.
443 lines
12 KiB
C
443 lines
12 KiB
C
/*
|
|
*
|
|
* Copyright © 2000,2008 Keith Packard
|
|
* 2005 Zack Rusin, Trolltech
|
|
*
|
|
* 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 Keith Packard not be used in
|
|
* advertising or publicity pertaining to distribution of the software without
|
|
* specific, written prior permission. Keith Packard makes 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.
|
|
*/
|
|
|
|
#ifndef UXAPRIV_H
|
|
#define UXAPRIV_H
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
#ifdef HAVE_DIX_CONFIG_H
|
|
#include <dix-config.h>
|
|
#else
|
|
#include <xorg-server.h>
|
|
#endif
|
|
#include "xf86.h"
|
|
|
|
#include "uxa.h"
|
|
|
|
#include <X11/X.h>
|
|
#define NEED_EVENTS
|
|
#include <X11/Xproto.h>
|
|
#ifdef MITSHM
|
|
#ifdef HAVE_XEXTPROTO_71
|
|
#include <X11/extensions/shm.h>
|
|
#else
|
|
#define _XSHM_SERVER_
|
|
#include <X11/extensions/shmstr.h>
|
|
#endif
|
|
#endif
|
|
#include "scrnintstr.h"
|
|
#include "pixmapstr.h"
|
|
#include "windowstr.h"
|
|
#include "servermd.h"
|
|
#include "mibstore.h"
|
|
#include "colormapst.h"
|
|
#include "gcstruct.h"
|
|
#include "input.h"
|
|
#include "mipointer.h"
|
|
#include "mi.h"
|
|
#include "dix.h"
|
|
#include "fb.h"
|
|
#include "fboverlay.h"
|
|
#ifdef RENDER
|
|
//#include "fbpict.h"
|
|
#include "glyphstr.h"
|
|
#endif
|
|
#include "damage.h"
|
|
|
|
/* Provide substitutes for gcc's __FUNCTION__ on other compilers */
|
|
#if !defined(__GNUC__) && !defined(__FUNCTION__)
|
|
# if defined(__STDC__) && (__STDC_VERSION__>=199901L) /* C99 */
|
|
# define __FUNCTION__ __func__
|
|
# else
|
|
# define __FUNCTION__ ""
|
|
# endif
|
|
#endif
|
|
|
|
/* 1.6 and earlier server compat */
|
|
#ifndef miGetCompositeClip
|
|
#define miCopyRegion fbCopyRegion
|
|
#define miDoCopy fbDoCopy
|
|
#endif
|
|
|
|
#define DEBUG_MIGRATE 0
|
|
#define DEBUG_PIXMAP 0
|
|
#define DEBUG_OFFSCREEN 0
|
|
#define DEBUG_GLYPH_CACHE 0
|
|
|
|
#define UXA_FALLBACK(x) \
|
|
if (uxa_get_screen(screen)->fallback_debug) { \
|
|
ErrorF("UXA fallback at %s: ", __FUNCTION__); \
|
|
ErrorF x; \
|
|
}
|
|
|
|
char uxa_drawable_location(DrawablePtr pDrawable);
|
|
|
|
#if DEBUG_PIXMAP
|
|
#define DBG_PIXMAP(a) ErrorF a
|
|
#else
|
|
#define DBG_PIXMAP(a)
|
|
#endif
|
|
|
|
typedef struct {
|
|
unsigned char sha1[20];
|
|
} uxa_cached_glyph_t;
|
|
|
|
typedef struct {
|
|
/* The identity of the cache, statically configured at initialization */
|
|
unsigned int format;
|
|
int glyphWidth;
|
|
int glyphHeight;
|
|
|
|
/* Size of cache; eventually this should be dynamically determined */
|
|
int size;
|
|
|
|
/* Hash table mapping from glyph sha1 to position in the glyph; we use
|
|
* open addressing with a hash table size determined based on size and large
|
|
* enough so that we always have a good amount of free space, so we can
|
|
* use linear probing. (Linear probing is preferrable to double hashing
|
|
* here because it allows us to easily remove entries.)
|
|
*/
|
|
int *hashEntries;
|
|
int hashSize;
|
|
|
|
uxa_cached_glyph_t *glyphs;
|
|
int glyphCount; /* Current number of glyphs */
|
|
|
|
PicturePtr picture; /* Where the glyphs of the cache are stored */
|
|
int yOffset; /* y location within the picture where the cache starts */
|
|
int columns; /* Number of columns the glyphs are layed out in */
|
|
int evictionPosition; /* Next random position to evict a glyph */
|
|
} uxa_glyph_cache_t;
|
|
|
|
#define UXA_NUM_GLYPH_CACHES 4
|
|
|
|
typedef struct {
|
|
uint32_t color;
|
|
PicturePtr picture;
|
|
} uxa_solid_cache_t;
|
|
|
|
#define UXA_NUM_SOLID_CACHE 16
|
|
|
|
typedef void (*EnableDisableFBAccessProcPtr) (int, Bool);
|
|
typedef struct {
|
|
uxa_driver_t *info;
|
|
CreateGCProcPtr SavedCreateGC;
|
|
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;
|
|
#endif
|
|
EnableDisableFBAccessProcPtr SavedEnableDisableFBAccess;
|
|
|
|
Bool fallback_debug;
|
|
Bool swappedOut;
|
|
unsigned disableFbCount;
|
|
unsigned offScreenCounter;
|
|
|
|
uxa_glyph_cache_t glyphCaches[UXA_NUM_GLYPH_CACHES];
|
|
|
|
PicturePtr solid_clear, solid_black, solid_white;
|
|
uxa_solid_cache_t solid_cache[UXA_NUM_SOLID_CACHE];
|
|
int solid_cache_size;
|
|
} uxa_screen_t;
|
|
|
|
/*
|
|
* This is the only completely portable way to
|
|
* compute this info.
|
|
*/
|
|
#ifndef BitsPerPixel
|
|
#define BitsPerPixel(d) (\
|
|
PixmapWidthPaddingInfo[d].notPower2 ? \
|
|
(PixmapWidthPaddingInfo[d].bytesPerPixel * 8) : \
|
|
((1 << PixmapWidthPaddingInfo[d].padBytesLog2) * 8 / \
|
|
(PixmapWidthPaddingInfo[d].padRoundUp+1)))
|
|
#endif
|
|
|
|
extern int uxa_screen_index;
|
|
static inline uxa_screen_t *uxa_get_screen(ScreenPtr screen)
|
|
{
|
|
return (uxa_screen_t *) dixLookupPrivate(&screen->devPrivates,
|
|
&uxa_screen_index);
|
|
}
|
|
|
|
/** Align an offset to an arbitrary alignment */
|
|
#define UXA_ALIGN(offset, align) (((offset) + (align) - 1) - \
|
|
(((offset) + (align) - 1) % (align)))
|
|
/** Align an offset to a power-of-two alignment */
|
|
#define UXA_ALIGN2(offset, align) (((offset) + (align) - 1) & ~((align) - 1))
|
|
|
|
typedef struct {
|
|
INT16 xSrc;
|
|
INT16 ySrc;
|
|
INT16 xDst;
|
|
INT16 yDst;
|
|
INT16 width;
|
|
INT16 height;
|
|
} uxa_composite_rect_t;
|
|
|
|
/**
|
|
* exaDDXDriverInit must be implemented by the DDX using EXA, and is the place
|
|
* to set EXA options or hook in screen functions to handle using EXA as the AA.
|
|
*/
|
|
void exaDDXDriverInit(ScreenPtr pScreen);
|
|
|
|
Bool uxa_prepare_access_window(WindowPtr pWin);
|
|
|
|
void uxa_finish_access_window(WindowPtr pWin);
|
|
|
|
/* uxa-unaccel.c */
|
|
Bool uxa_prepare_access_gc(GCPtr pGC);
|
|
|
|
void uxa_finish_access_gc(GCPtr pGC);
|
|
|
|
void
|
|
uxa_check_fill_spans(DrawablePtr pDrawable, GCPtr pGC, int nspans,
|
|
DDXPointPtr ppt, int *pwidth, int fSorted);
|
|
|
|
void
|
|
uxa_check_set_spans(DrawablePtr pDrawable, GCPtr pGC, char *psrc,
|
|
DDXPointPtr ppt, int *pwidth, int nspans, int fSorted);
|
|
|
|
void
|
|
uxa_check_put_image(DrawablePtr pDrawable, GCPtr pGC, int depth,
|
|
int x, int y, int w, int h, int leftPad, int format,
|
|
char *bits);
|
|
|
|
RegionPtr
|
|
uxa_check_copy_area(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
|
|
int srcx, int srcy, int w, int h, int dstx, int dsty);
|
|
|
|
RegionPtr
|
|
uxa_check_copy_plane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
|
|
int srcx, int srcy, int w, int h, int dstx, int dsty,
|
|
unsigned long bitPlane);
|
|
|
|
void
|
|
uxa_check_poly_point(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
|
|
DDXPointPtr pptInit);
|
|
|
|
void
|
|
uxa_check_poly_lines(DrawablePtr pDrawable, GCPtr pGC,
|
|
int mode, int npt, DDXPointPtr ppt);
|
|
|
|
void
|
|
uxa_check_poly_segment(DrawablePtr pDrawable, GCPtr pGC,
|
|
int nsegInit, xSegment * pSegInit);
|
|
|
|
void
|
|
uxa_check_poly_arc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc * pArcs);
|
|
|
|
void
|
|
uxa_check_poly_fill_rect(DrawablePtr pDrawable, GCPtr pGC,
|
|
int nrect, xRectangle * prect);
|
|
|
|
void
|
|
uxa_check_image_glyph_blt(DrawablePtr pDrawable, GCPtr pGC,
|
|
int x, int y, unsigned int nglyph,
|
|
CharInfoPtr * ppci, pointer pglyphBase);
|
|
|
|
void
|
|
uxa_check_poly_glyph_blt(DrawablePtr pDrawable, GCPtr pGC,
|
|
int x, int y, unsigned int nglyph,
|
|
CharInfoPtr * ppci, pointer pglyphBase);
|
|
|
|
void
|
|
uxa_check_push_pixels(GCPtr pGC, PixmapPtr pBitmap,
|
|
DrawablePtr pDrawable, int w, int h, int x, int y);
|
|
|
|
void
|
|
uxa_check_get_spans(DrawablePtr pDrawable,
|
|
int wMax,
|
|
DDXPointPtr ppt, int *pwidth, int nspans, char *pdstStart);
|
|
|
|
void uxa_check_paint_window(WindowPtr pWin, RegionPtr pRegion, int what);
|
|
|
|
void
|
|
uxa_check_add_traps(PicturePtr pPicture,
|
|
INT16 x_off, INT16 y_off, int ntrap, xTrap * traps);
|
|
|
|
/* uxa-accel.c */
|
|
|
|
static _X_INLINE Bool
|
|
uxa_gc_reads_destination(DrawablePtr pDrawable, unsigned long planemask,
|
|
unsigned int fillStyle, unsigned char alu)
|
|
{
|
|
return ((alu != GXcopy && alu != GXclear && alu != GXset &&
|
|
alu != GXcopyInverted) || fillStyle == FillStippled ||
|
|
!UXA_PM_IS_SOLID(pDrawable, planemask));
|
|
}
|
|
|
|
void uxa_copy_window(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc);
|
|
|
|
Bool
|
|
uxa_fill_region_tiled(DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
|
|
DDXPointPtr pPatOrg, CARD32 planemask, CARD32 alu);
|
|
|
|
void
|
|
uxa_shm_put_image(DrawablePtr pDrawable, GCPtr pGC, int depth,
|
|
unsigned int format, int w, int h, int sx, int sy, int sw,
|
|
int sh, int dx, int dy, char *data);
|
|
|
|
void uxa_paint_window(WindowPtr pWin, RegionPtr pRegion, int what);
|
|
|
|
void
|
|
uxa_get_image(DrawablePtr pDrawable, int x, int y, int w, int h,
|
|
unsigned int format, unsigned long planeMask, char *d);
|
|
|
|
extern const GCOps uxa_ops;
|
|
|
|
#ifdef MITSHM
|
|
/* XXX these come from shmint.h, which isn't exported by the server */
|
|
|
|
#ifdef HAVE_XEXTPROTO_71
|
|
#include "shmint.h"
|
|
#else
|
|
|
|
void ShmRegisterFuncs(ScreenPtr pScreen, ShmFuncsPtr funcs);
|
|
|
|
void ShmSetPixmapFormat(ScreenPtr pScreen, int format);
|
|
|
|
void fbShmPutImage(XSHM_PUT_IMAGE_ARGS);
|
|
#endif
|
|
|
|
extern ShmFuncs uxa_shm_funcs;
|
|
|
|
#endif
|
|
|
|
#ifdef RENDER
|
|
|
|
/* XXX these are in fbpict.h, which is not installed */
|
|
void
|
|
fbComposite(CARD8 op,
|
|
PicturePtr pSrc,
|
|
PicturePtr pMask,
|
|
PicturePtr pDst,
|
|
INT16 xSrc,
|
|
INT16 ySrc,
|
|
INT16 xMask,
|
|
INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height);
|
|
|
|
void
|
|
fbAddTraps(PicturePtr pPicture,
|
|
INT16 xOff, INT16 yOff, int ntrap, xTrap * traps);
|
|
|
|
void
|
|
uxa_check_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);
|
|
#endif
|
|
|
|
/* uxa.c */
|
|
Bool uxa_prepare_access(DrawablePtr pDrawable, uxa_access_t access);
|
|
|
|
void uxa_finish_access(DrawablePtr pDrawable);
|
|
|
|
void
|
|
uxa_get_drawable_deltas(DrawablePtr pDrawable, PixmapPtr pPixmap,
|
|
int *xp, int *yp);
|
|
|
|
Bool uxa_drawable_is_offscreen(DrawablePtr pDrawable);
|
|
|
|
Bool uxa_pixmap_is_offscreen(PixmapPtr p);
|
|
|
|
PixmapPtr uxa_get_offscreen_pixmap(DrawablePtr pDrawable, int *xp, int *yp);
|
|
|
|
PixmapPtr uxa_get_drawable_pixmap(DrawablePtr pDrawable);
|
|
|
|
RegionPtr
|
|
uxa_copy_area(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC,
|
|
int srcx, int srcy, int width, int height, int dstx, int dsty);
|
|
|
|
void
|
|
uxa_copy_n_to_n(DrawablePtr pSrcDrawable,
|
|
DrawablePtr pDstDrawable,
|
|
GCPtr pGC,
|
|
BoxPtr pbox,
|
|
int nbox,
|
|
int dx,
|
|
int dy,
|
|
Bool reverse, Bool upsidedown, Pixel bitplane, void *closure);
|
|
|
|
/* uxa_render.c */
|
|
Bool uxa_op_reads_destination(CARD8 op);
|
|
|
|
void
|
|
uxa_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);
|
|
|
|
void
|
|
uxa_composite_rects(CARD8 op,
|
|
PicturePtr pSrc,
|
|
PicturePtr pDst, int nrect, uxa_composite_rect_t * rects);
|
|
|
|
void
|
|
uxa_trapezoids(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
|
|
PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
|
|
int ntrap, xTrapezoid * traps);
|
|
|
|
void
|
|
uxa_triangles(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
|
|
PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
|
|
int ntri, xTriangle * tris);
|
|
|
|
/* uxa_glyph.c */
|
|
void uxa_glyphs_init(ScreenPtr pScreen);
|
|
|
|
void uxa_glyphs_fini(ScreenPtr pScreen);
|
|
|
|
void
|
|
uxa_glyphs(CARD8 op,
|
|
PicturePtr pSrc,
|
|
PicturePtr pDst,
|
|
PictFormatPtr maskFormat,
|
|
INT16 xSrc,
|
|
INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs);
|
|
|
|
#endif /* UXAPRIV_H */
|