AlexIndustrial/mesa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

g3dvl: Add Nouveau winsys, libdriclient.

Browse Source 
Nouveau winsys is based on Mesa's Nouveau winsys and soft-links to most of
it. The 'nouveau_context' and 'nouveau_screen' code contains most of the
changes, 'nouveau_winsys_pipe', 'nouveau_swapbuffers' and 'nouveau_lock'
contain some minor changes. The driclient library contains the DRI
userland stuff, most of which was based on Mesa's DRI code.
This commit is contained in:
Younes Manton
2008-07-22 22:26:26 -04:00
parent 90bd0e338d
commit 0c25ac5242
46 changed files with 2896 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/driclient/include/driclient.h
+98
View File
@@ -0,0 +1,98 @@
#ifndef driclient_h
#define driclient_h
#include <stdint.h>
#include <X11/Xlib.h>
#include <drm_sarea.h>
#include "xf86dri.h"
/* TODO: Bring in DRI XML options */
typedef struct dri_version
{
int major;
int minor;
int patch;
} dri_version_t;
typedef struct dri_screen
{
Display *display;
unsigned int num;
dri_version_t ddx, dri, drm;
int draw_lock_id;
int fd;
drm_sarea_t *sarea;
void *drawable_hash;
void *private;
} dri_screen_t;
struct dri_context;
typedef struct dri_drawable
{
drm_drawable_t drm_drawable;
Drawable x_drawable;
unsigned int sarea_index;
unsigned int *sarea_stamp;
unsigned int last_sarea_stamp;
int x, y, w, h;
int back_x, back_y;
int num_cliprects, num_back_cliprects;
drm_clip_rect_t *cliprects, *back_cliprects;
dri_screen_t *dri_screen;
unsigned int refcount;
void *private;
} dri_drawable_t;
typedef struct dri_context
{
XID id;
drm_context_t drm_context;
dri_screen_t *dri_screen;
void *private;
} dri_context_t;
typedef struct dri_framebuffer
{
drm_handle_t drm_handle;
int base, size, stride;
int private_size;
void *private;
} dri_framebuffer_t;
int driCreateScreen(Display *display, int screen, dri_screen_t **dri_screen, dri_framebuffer_t *dri_framebuf);
int driDestroyScreen(dri_screen_t *dri_screen);
int driCreateDrawable(dri_screen_t *dri_screen, Drawable drawable, dri_drawable_t **dri_drawable);
int driUpdateDrawableInfo(dri_drawable_t *dri_drawable);
int driDestroyDrawable(dri_drawable_t *dri_drawable);
int driCreateContext(dri_screen_t *dri_screen, Visual *visual, dri_context_t **dri_context);
int driDestroyContext(dri_context_t *dri_context);
int driCompareVersions(const dri_version_t *v1, const dri_version_t *v2);
#define DRI_VALIDATE_DRAWABLE_INFO_ONCE(dri_drawable) \
do \
{ \
if (*(dri_drawable->sarea_stamp) != dri_drawable->last_sarea_stamp) \
driUpdateDrawableInfo(dri_drawable); \
} while (0)
#define DRI_VALIDATE_DRAWABLE_INFO(dri_screen, dri_drawable) \
do \
{ \
while (*(dri_drawable->sarea_stamp) != dri_drawable->last_sarea_stamp) \
{ \
register unsigned int hwContext = dri_screen->sarea->lock.lock & \
~(DRM_LOCK_HELD | DRM_LOCK_CONT); \
DRM_UNLOCK(dri_screen->fd, &dri_screen->sarea->lock, hwContext); \
\
DRM_SPINLOCK(&dri_screen->sarea->drawable_lock, dri_screen->draw_lock_id); \
DRI_VALIDATE_DRAWABLE_INFO_ONCE(dri_drawable); \
DRM_SPINUNLOCK(&dri_screen->sarea->drawable_lock, dri_screen->draw_lock_id); \
\
DRM_LIGHT_LOCK(dri_screen->fd, &dri_screen->sarea->lock, hwContext); \
} \
} while (0)
#endif
src/driclient/include/xf86dri.h
+119
View File
@@ -0,0 +1,119 @@
/**************************************************************************
Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
Copyright 2000 VA Linux Systems, Inc.
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, sub license, 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 NON-INFRINGEMENT.
IN NO EVENT SHALL PRECISION INSIGHT 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.
**************************************************************************/
/**
* \file xf86dri.h
* Protocol numbers and function prototypes for DRI X protocol.
*
* \author Kevin E. Martin <martin@valinux.com>
* \author Jens Owen <jens@tungstengraphics.com>
* \author Rickard E. (Rik) Faith <faith@valinux.com>
*/
#ifndef _XF86DRI_H_
#define _XF86DRI_H_
#include <X11/Xfuncproto.h>
#include <xf86drm.h>
#define X_XF86DRIQueryVersion 0
#define X_XF86DRIQueryDirectRenderingCapable 1
#define X_XF86DRIOpenConnection 2
#define X_XF86DRICloseConnection 3
#define X_XF86DRIGetClientDriverName 4
#define X_XF86DRICreateContext 5
#define X_XF86DRIDestroyContext 6
#define X_XF86DRICreateDrawable 7
#define X_XF86DRIDestroyDrawable 8
#define X_XF86DRIGetDrawableInfo 9
#define X_XF86DRIGetDeviceInfo 10
#define X_XF86DRIAuthConnection 11
#define X_XF86DRIOpenFullScreen 12 /* Deprecated */
#define X_XF86DRICloseFullScreen 13 /* Deprecated */
#define XF86DRINumberEvents 0
#define XF86DRIClientNotLocal 0
#define XF86DRIOperationNotSupported 1
#define XF86DRINumberErrors (XF86DRIOperationNotSupported + 1)
#ifndef _XF86DRI_SERVER_
_XFUNCPROTOBEGIN
Bool XF86DRIQueryExtension( Display *dpy, int *event_base, int *error_base );
Bool XF86DRIQueryVersion( Display *dpy, int *majorVersion, int *minorVersion,
int *patchVersion );
Bool XF86DRIQueryDirectRenderingCapable( Display *dpy, int screen,
Bool *isCapable );
Bool XF86DRIOpenConnection( Display *dpy, int screen, drm_handle_t *hSAREA,
char **busIDString );
Bool XF86DRIAuthConnection( Display *dpy, int screen, drm_magic_t magic );
Bool XF86DRICloseConnection( Display *dpy, int screen );
Bool XF86DRIGetClientDriverName( Display *dpy, int screen,
int *ddxDriverMajorVersion, int *ddxDriverMinorVersion,
int *ddxDriverPatchVersion, char **clientDriverName );
Bool XF86DRICreateContext( Display *dpy, int screen, Visual *visual,
XID *ptr_to_returned_context_id, drm_context_t *hHWContext );
Bool XF86DRICreateContextWithConfig( Display *dpy, int screen, int configID,
XID *ptr_to_returned_context_id, drm_context_t *hHWContext );
Bool XF86DRIDestroyContext( Display *dpy, int screen,
XID context_id );
Bool XF86DRICreateDrawable( Display *dpy, int screen,
Drawable drawable, drm_drawable_t *hHWDrawable );
Bool XF86DRIDestroyDrawable( Display *dpy, int screen,
Drawable drawable);
Bool XF86DRIGetDrawableInfo( Display *dpy, int screen, Drawable drawable,
unsigned int *index, unsigned int *stamp,
int *X, int *Y, int *W, int *H,
int *numClipRects, drm_clip_rect_t ** pClipRects,
int *backX, int *backY,
int *numBackClipRects, drm_clip_rect_t **pBackClipRects );
Bool XF86DRIGetDeviceInfo( Display *dpy, int screen,
drm_handle_t *hFrameBuffer, int *fbOrigin, int *fbSize,
int *fbStride, int *devPrivateSize, void **pDevPrivate );
_XFUNCPROTOEND
#endif /* _XF86DRI_SERVER_ */
#endif /* _XF86DRI_H_ */
src/driclient/src/Makefile
+22
View File
@@ -0,0 +1,22 @@
TARGET = libdriclient.a
OBJECTS = driclient.o XF86dri.o
DRMDIR ?= /usr
CFLAGS += -g -Wall -fPIC -Werror -I../include -I${DRMDIR}/include -I${DRMDIR}/include/drm
#############################################
.PHONY = all clean
all: ${TARGET} test
${TARGET}: ${OBJECTS}
ar rcs $@ $^
cp ${TARGET} ../lib
test: test.o
$(CC) -L../lib -L${DRMDIR}/lib ${LDFLAGS} -o $@ $^ -ldriclient -lX11 -lXext -ldrm
clean:
rm -rf ${OBJECTS} ${TARGET} test test.o
src/driclient/src/XF86dri.c
+619
View File
@@ -0,0 +1,619 @@
/**************************************************************************
Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
Copyright 2000 VA Linux Systems, Inc.
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, sub license, 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 NON-INFRINGEMENT.
IN NO EVENT SHALL PRECISION INSIGHT 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:
* Kevin E. Martin <martin@valinux.com>
* Jens Owen <jens@tungstengraphics.com>
* Rickard E. (Rik) Faith <faith@valinux.com>
*
*/
/* THIS IS NOT AN X CONSORTIUM STANDARD */
#define NEED_REPLIES
#include <X11/Xlibint.h>
#include <X11/extensions/Xext.h>
#include <X11/extensions/extutil.h>
#include "xf86dristr.h"
static XExtensionInfo _xf86dri_info_data;
static XExtensionInfo *xf86dri_info = &_xf86dri_info_data;
static char xf86dri_extension_name[] = XF86DRINAME;
#define XF86DRICheckExtension(dpy,i,val) \
XextCheckExtension (dpy, i, xf86dri_extension_name, val)
/*****************************************************************************
* *
* private utility routines *
* *
*****************************************************************************/
static int close_display(Display *dpy, XExtCodes *extCodes);
static /* const */ XExtensionHooks xf86dri_extension_hooks = {
NULL, /* create_gc */
NULL, /* copy_gc */
NULL, /* flush_gc */
NULL, /* free_gc */
NULL, /* create_font */
NULL, /* free_font */
close_display, /* close_display */
NULL, /* wire_to_event */
NULL, /* event_to_wire */
NULL, /* error */
NULL, /* error_string */
};
static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86dri_info,
xf86dri_extension_name,
&xf86dri_extension_hooks,
0, NULL)
static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86dri_info)
/*****************************************************************************
* *
* public XFree86-DRI Extension routines *
* *
*****************************************************************************/
#if 0
#include <stdio.h>
#define TRACE(msg) fprintf(stderr,"XF86DRI%s\n", msg);
#else
#define TRACE(msg)
#endif
#define PUBLIC
PUBLIC Bool XF86DRIQueryExtension (dpy, event_basep, error_basep)
Display *dpy;
int *event_basep, *error_basep;
{
XExtDisplayInfo *info = find_display (dpy);
TRACE("QueryExtension...");
if (XextHasExtension(info)) {
*event_basep = info->codes->first_event;
*error_basep = info->codes->first_error;
TRACE("QueryExtension... return True");
return True;
} else {
TRACE("QueryExtension... return False");
return False;
}
}
PUBLIC Bool XF86DRIQueryVersion(dpy, majorVersion, minorVersion, patchVersion)
Display* dpy;
int* majorVersion;
int* minorVersion;
int* patchVersion;
{
XExtDisplayInfo *info = find_display (dpy);
xXF86DRIQueryVersionReply rep;
xXF86DRIQueryVersionReq *req;
TRACE("QueryVersion...");
XF86DRICheckExtension (dpy, info, False);
LockDisplay(dpy);
GetReq(XF86DRIQueryVersion, req);
req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIQueryVersion;
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
TRACE("QueryVersion... return False");
return False;
}
*majorVersion = rep.majorVersion;
*minorVersion = rep.minorVersion;
*patchVersion = rep.patchVersion;
UnlockDisplay(dpy);
SyncHandle();
TRACE("QueryVersion... return True");
return True;
}
PUBLIC Bool XF86DRIQueryDirectRenderingCapable(dpy, screen, isCapable)
Display* dpy;
int screen;
Bool* isCapable;
{
XExtDisplayInfo *info = find_display (dpy);
xXF86DRIQueryDirectRenderingCapableReply rep;
xXF86DRIQueryDirectRenderingCapableReq *req;
TRACE("QueryDirectRenderingCapable...");
XF86DRICheckExtension (dpy, info, False);
LockDisplay(dpy);
GetReq(XF86DRIQueryDirectRenderingCapable, req);
req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIQueryDirectRenderingCapable;
req->screen = screen;
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
TRACE("QueryDirectRenderingCapable... return False");
return False;
}
*isCapable = rep.isCapable;
UnlockDisplay(dpy);
SyncHandle();
TRACE("QueryDirectRenderingCapable... return True");
return True;
}
PUBLIC Bool XF86DRIOpenConnection(dpy, screen, hSAREA, busIdString)
Display* dpy;
int screen;
drm_handle_t * hSAREA;
char **busIdString;
{
XExtDisplayInfo *info = find_display (dpy);
xXF86DRIOpenConnectionReply rep;
xXF86DRIOpenConnectionReq *req;
TRACE("OpenConnection...");
XF86DRICheckExtension (dpy, info, False);
LockDisplay(dpy);
GetReq(XF86DRIOpenConnection, req);
req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIOpenConnection;
req->screen = screen;
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
TRACE("OpenConnection... return False");
return False;
}
*hSAREA = rep.hSAREALow;
if (sizeof(drm_handle_t) == 8) {
int shift = 32; /* var to prevent warning on next line */
*hSAREA |= ((drm_handle_t) rep.hSAREAHigh) << shift;
}
if (rep.length) {
if (!(*busIdString = (char *)Xcalloc(rep.busIdStringLength + 1, 1))) {
_XEatData(dpy, ((rep.busIdStringLength+3) & ~3));
UnlockDisplay(dpy);
SyncHandle();
TRACE("OpenConnection... return False");
return False;
}
_XReadPad(dpy, *busIdString, rep.busIdStringLength);
} else {
*busIdString = NULL;
}
UnlockDisplay(dpy);
SyncHandle();
TRACE("OpenConnection... return True");
return True;
}
PUBLIC Bool XF86DRIAuthConnection(dpy, screen, magic)
Display* dpy;
int screen;
drm_magic_t magic;
{
XExtDisplayInfo *info = find_display (dpy);
xXF86DRIAuthConnectionReq *req;
xXF86DRIAuthConnectionReply rep;
TRACE("AuthConnection...");
XF86DRICheckExtension (dpy, info, False);
LockDisplay(dpy);
GetReq(XF86DRIAuthConnection, req);
req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIAuthConnection;
req->screen = screen;
req->magic = magic;
rep.authenticated = 0;
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.authenticated) {
UnlockDisplay(dpy);
SyncHandle();
TRACE("AuthConnection... return False");
return False;
}
UnlockDisplay(dpy);
SyncHandle();
TRACE("AuthConnection... return True");
return True;
}
PUBLIC Bool XF86DRICloseConnection(dpy, screen)
Display* dpy;
int screen;
{
XExtDisplayInfo *info = find_display (dpy);
xXF86DRICloseConnectionReq *req;
TRACE("CloseConnection...");
XF86DRICheckExtension (dpy, info, False);
LockDisplay(dpy);
GetReq(XF86DRICloseConnection, req);
req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRICloseConnection;
req->screen = screen;
UnlockDisplay(dpy);
SyncHandle();
TRACE("CloseConnection... return True");
return True;
}
PUBLIC Bool XF86DRIGetClientDriverName(dpy, screen, ddxDriverMajorVersion,
ddxDriverMinorVersion, ddxDriverPatchVersion, clientDriverName)
Display* dpy;
int screen;
int* ddxDriverMajorVersion;
int* ddxDriverMinorVersion;
int* ddxDriverPatchVersion;
char** clientDriverName;
{
XExtDisplayInfo *info = find_display (dpy);
xXF86DRIGetClientDriverNameReply rep;
xXF86DRIGetClientDriverNameReq *req;
TRACE("GetClientDriverName...");
XF86DRICheckExtension (dpy, info, False);
LockDisplay(dpy);
GetReq(XF86DRIGetClientDriverName, req);
req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIGetClientDriverName;
req->screen = screen;
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
TRACE("GetClientDriverName... return False");
return False;
}
*ddxDriverMajorVersion = rep.ddxDriverMajorVersion;
*ddxDriverMinorVersion = rep.ddxDriverMinorVersion;
*ddxDriverPatchVersion = rep.ddxDriverPatchVersion;
if (rep.length) {
if (!(*clientDriverName = (char *)Xcalloc(rep.clientDriverNameLength + 1, 1))) {
_XEatData(dpy, ((rep.clientDriverNameLength+3) & ~3));
UnlockDisplay(dpy);
SyncHandle();
TRACE("GetClientDriverName... return False");
return False;
}
_XReadPad(dpy, *clientDriverName, rep.clientDriverNameLength);
} else {
*clientDriverName = NULL;
}
UnlockDisplay(dpy);
SyncHandle();
TRACE("GetClientDriverName... return True");
return True;
}
PUBLIC Bool XF86DRICreateContextWithConfig(dpy, screen, configID, context,
hHWContext)
Display* dpy;
int screen;
int configID;
XID* context;
drm_context_t * hHWContext;
{
XExtDisplayInfo *info = find_display (dpy);
xXF86DRICreateContextReply rep;
xXF86DRICreateContextReq *req;
TRACE("CreateContext...");
XF86DRICheckExtension (dpy, info, False);
LockDisplay(dpy);
GetReq(XF86DRICreateContext, req);
req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRICreateContext;
req->visual = configID;
req->screen = screen;
*context = XAllocID(dpy);
req->context = *context;
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
TRACE("CreateContext... return False");
return False;
}
*hHWContext = rep.hHWContext;
UnlockDisplay(dpy);
SyncHandle();
TRACE("CreateContext... return True");
return True;
}
PUBLIC Bool XF86DRICreateContext(dpy, screen, visual, context, hHWContext)
Display* dpy;
int screen;
Visual* visual;
XID* context;
drm_context_t * hHWContext;
{
return XF86DRICreateContextWithConfig( dpy, screen, visual->visualid,
context, hHWContext );
}
PUBLIC Bool XF86DRIDestroyContext( Display * ndpy, int screen,
XID context )
{
Display * const dpy = (Display *) ndpy;
XExtDisplayInfo *info = find_display (dpy);
xXF86DRIDestroyContextReq *req;
TRACE("DestroyContext...");
XF86DRICheckExtension (dpy, info, False);
LockDisplay(dpy);
GetReq(XF86DRIDestroyContext, req);
req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIDestroyContext;
req->screen = screen;
req->context = context;
UnlockDisplay(dpy);
SyncHandle();
TRACE("DestroyContext... return True");
return True;
}
PUBLIC Bool XF86DRICreateDrawable( Display * ndpy, int screen,
Drawable drawable, drm_drawable_t * hHWDrawable )
{
Display * const dpy = (Display *) ndpy;
XExtDisplayInfo *info = find_display (dpy);
xXF86DRICreateDrawableReply rep;
xXF86DRICreateDrawableReq *req;
TRACE("CreateDrawable...");
XF86DRICheckExtension (dpy, info, False);
LockDisplay(dpy);
GetReq(XF86DRICreateDrawable, req);
req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRICreateDrawable;
req->screen = screen;
req->drawable = drawable;
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
TRACE("CreateDrawable... return False");
return False;
}
*hHWDrawable = rep.hHWDrawable;
UnlockDisplay(dpy);
SyncHandle();
TRACE("CreateDrawable... return True");
return True;
}
PUBLIC Bool XF86DRIDestroyDrawable( Display * ndpy, int screen,
Drawable drawable )
{
Display * const dpy = (Display *) ndpy;
XExtDisplayInfo *info = find_display (dpy);
xXF86DRIDestroyDrawableReq *req;
TRACE("DestroyDrawable...");
XF86DRICheckExtension (dpy, info, False);
LockDisplay(dpy);
GetReq(XF86DRIDestroyDrawable, req);
req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIDestroyDrawable;
req->screen = screen;
req->drawable = drawable;
UnlockDisplay(dpy);
SyncHandle();
TRACE("DestroyDrawable... return True");
return True;
}
PUBLIC Bool XF86DRIGetDrawableInfo(Display* dpy, int screen, Drawable drawable,
unsigned int* index, unsigned int* stamp,
int* X, int* Y, int* W, int* H,
int* numClipRects, drm_clip_rect_t ** pClipRects,
int* backX, int* backY,
int* numBackClipRects, drm_clip_rect_t ** pBackClipRects )
{
XExtDisplayInfo *info = find_display (dpy);
xXF86DRIGetDrawableInfoReply rep;
xXF86DRIGetDrawableInfoReq *req;
int total_rects;
TRACE("GetDrawableInfo...");
XF86DRICheckExtension (dpy, info, False);
LockDisplay(dpy);
GetReq(XF86DRIGetDrawableInfo, req);
req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIGetDrawableInfo;
req->screen = screen;
req->drawable = drawable;
if (!_XReply(dpy, (xReply *)&rep, 1, xFalse))
{
UnlockDisplay(dpy);
SyncHandle();
TRACE("GetDrawableInfo... return False");
return False;
}
*index = rep.drawableTableIndex;
*stamp = rep.drawableTableStamp;
*X = (int)rep.drawableX;
*Y = (int)rep.drawableY;
*W = (int)rep.drawableWidth;
*H = (int)rep.drawableHeight;
*numClipRects = rep.numClipRects;
total_rects = *numClipRects;
*backX = rep.backX;
*backY = rep.backY;
*numBackClipRects = rep.numBackClipRects;
total_rects += *numBackClipRects;
#if 0
/* Because of the fix in Xserver/GL/dri/xf86dri.c, this check breaks
* backwards compatibility (Because of the >> 2 shift) but the fix
* enables multi-threaded apps to work.
*/
if (rep.length != ((((SIZEOF(xXF86DRIGetDrawableInfoReply) -
SIZEOF(xGenericReply) +
total_rects * sizeof(drm_clip_rect_t)) + 3) & ~3) >> 2)) {
_XEatData(dpy, rep.length);
UnlockDisplay(dpy);
SyncHandle();
TRACE("GetDrawableInfo... return False");
return False;
}
#endif
if (*numClipRects) {
int len = sizeof(drm_clip_rect_t) * (*numClipRects);
*pClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
if (*pClipRects)
_XRead(dpy, (char*)*pClipRects, len);
} else {
*pClipRects = NULL;
}
if (*numBackClipRects) {
int len = sizeof(drm_clip_rect_t) * (*numBackClipRects);
*pBackClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
if (*pBackClipRects)
_XRead(dpy, (char*)*pBackClipRects, len);
} else {
*pBackClipRects = NULL;
}
UnlockDisplay(dpy);
SyncHandle();
TRACE("GetDrawableInfo... return True");
return True;
}
PUBLIC Bool XF86DRIGetDeviceInfo(dpy, screen, hFrameBuffer,
fbOrigin, fbSize, fbStride, devPrivateSize, pDevPrivate)
Display* dpy;
int screen;
drm_handle_t * hFrameBuffer;
int* fbOrigin;
int* fbSize;
int* fbStride;
int* devPrivateSize;
void** pDevPrivate;
{
XExtDisplayInfo *info = find_display (dpy);
xXF86DRIGetDeviceInfoReply rep;
xXF86DRIGetDeviceInfoReq *req;
TRACE("GetDeviceInfo...");
XF86DRICheckExtension (dpy, info, False);
LockDisplay(dpy);
GetReq(XF86DRIGetDeviceInfo, req);
req->reqType = info->codes->major_opcode;
req->driReqType = X_XF86DRIGetDeviceInfo;
req->screen = screen;
if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
UnlockDisplay(dpy);
SyncHandle();
TRACE("GetDeviceInfo... return False");
return False;
}
*hFrameBuffer = rep.hFrameBufferLow;
if (sizeof(drm_handle_t) == 8) {
int shift = 32; /* var to prevent warning on next line */
*hFrameBuffer |= ((drm_handle_t) rep.hFrameBufferHigh) << shift;
}
*fbOrigin = rep.framebufferOrigin;
*fbSize = rep.framebufferSize;
*fbStride = rep.framebufferStride;
*devPrivateSize = rep.devPrivateSize;
if (rep.length) {
if (!(*pDevPrivate = (void *)Xcalloc(rep.devPrivateSize, 1))) {
_XEatData(dpy, ((rep.devPrivateSize+3) & ~3));
UnlockDisplay(dpy);
SyncHandle();
TRACE("GetDeviceInfo... return False");
return False;
}
_XRead(dpy, (char*)*pDevPrivate, rep.devPrivateSize);
} else {
*pDevPrivate = NULL;
}
UnlockDisplay(dpy);
SyncHandle();
TRACE("GetDeviceInfo... return True");
return True;
}
PUBLIC Bool XF86DRIOpenFullScreen(dpy, screen, drawable)
Display* dpy;
int screen;
Drawable drawable;
{
/* This function and the underlying X protocol are deprecated.
*/
(void) dpy;
(void) screen;
(void) drawable;
return False;
}
PUBLIC Bool XF86DRICloseFullScreen(dpy, screen, drawable)
Display* dpy;
int screen;
Drawable drawable;
{
/* This function and the underlying X protocol are deprecated.
*/
(void) dpy;
(void) screen;
(void) drawable;
return True;
}
src/driclient/src/driclient.c
+292
View File
@@ -0,0 +1,292 @@
#include "driclient.h"
#include <assert.h>
#include <stdlib.h>
int driCreateScreen(Display *display, int screen, dri_screen_t **dri_screen, dri_framebuffer_t *dri_framebuf)
{
int evbase, errbase;
char *driver_name;
int newly_opened;
drm_magic_t magic;
drmVersionPtr drm_version;
drm_handle_t sarea_handle;
char *bus_id;
dri_screen_t *dri_scrn;
assert(display);
assert(dri_screen);
if (!XF86DRIQueryExtension(display, &evbase, &errbase))
return 1;
dri_scrn = calloc(1, sizeof(dri_screen_t));
if (!dri_scrn)
return 1;
if (!XF86DRIQueryVersion(display, &dri_scrn->dri.major, &dri_scrn->dri.minor, &dri_scrn->dri.patch))
goto free_screen;
dri_scrn->display = display;
dri_scrn->num = screen;
dri_scrn->draw_lock_id = 1;
if (!XF86DRIOpenConnection(display, screen, &sarea_handle, &bus_id))
goto free_screen;
dri_scrn->fd = -1;
dri_scrn->fd = drmOpenOnce(NULL, bus_id, &newly_opened);
XFree(bus_id);
if (dri_scrn->fd < 0)
goto close_connection;
if (drmGetMagic(dri_scrn->fd, &magic))
goto close_drm;
drm_version = drmGetVersion(dri_scrn->fd);
if (!drm_version)
goto close_drm;
dri_scrn->drm.major = drm_version->version_major;
dri_scrn->drm.minor = drm_version->version_minor;
dri_scrn->drm.patch = drm_version->version_patchlevel;
drmFreeVersion(drm_version);
if (!XF86DRIAuthConnection(display, screen, magic))
goto close_drm;
if (!XF86DRIGetClientDriverName
(
display,
screen,
&dri_scrn->ddx.major,
&dri_scrn->ddx.minor,
&dri_scrn->ddx.patch,
&driver_name
))
goto close_drm;
if (drmMap(dri_scrn->fd, sarea_handle, SAREA_MAX, (drmAddress)&dri_scrn->sarea))
goto close_drm;
dri_scrn->drawable_hash = drmHashCreate();
if (!dri_scrn->drawable_hash)
goto unmap_sarea;
if (dri_framebuf)
{
if (!XF86DRIGetDeviceInfo
(
display,
screen, &dri_framebuf->drm_handle,
&dri_framebuf->base,
&dri_framebuf->size,
&dri_framebuf->stride,
&dri_framebuf->private_size,
&dri_framebuf->private
))
goto destroy_hash;
}
*dri_screen = dri_scrn;
return 0;
destroy_hash:
drmHashDestroy(dri_scrn->drawable_hash);
unmap_sarea:
drmUnmap(dri_scrn->sarea, SAREA_MAX);
close_drm:
drmCloseOnce(dri_scrn->fd);
close_connection:
XF86DRICloseConnection(display, screen);
free_screen:
free(dri_scrn);
return 1;
}
int driDestroyScreen(dri_screen_t *dri_screen)
{
assert(dri_screen);
drmHashDestroy(dri_screen->drawable_hash);
drmUnmap(dri_screen->sarea, SAREA_MAX);
drmCloseOnce(dri_screen->fd);
XF86DRICloseConnection(dri_screen->display, dri_screen->num);
free(dri_screen);
return 0;
}
int driCreateDrawable(dri_screen_t *dri_screen, Drawable drawable, dri_drawable_t **dri_drawable)
{
int evbase, errbase;
dri_drawable_t *dri_draw;
assert(dri_screen);
assert(dri_drawable);
if (!XF86DRIQueryExtension(dri_screen->display, &evbase, &errbase))
return 1;
if (!drmHashLookup(dri_screen->drawable_hash, drawable, (void**)dri_drawable))
{
/* Found */
(*dri_drawable)->refcount++;
return 0;
}
dri_draw = calloc(1, sizeof(dri_drawable_t));
if (!dri_draw)
return 1;
if (!XF86DRICreateDrawable(dri_screen->display, 0, drawable, &dri_draw->drm_drawable))
{
free(dri_draw);
return 1;
}
dri_draw->x_drawable = drawable;
dri_draw->sarea_index = 0;
dri_draw->sarea_stamp = NULL;
dri_draw->last_sarea_stamp = 0;
dri_draw->dri_screen = dri_screen;
dri_draw->refcount = 1;
if (drmHashInsert(dri_screen->drawable_hash, drawable, dri_draw))
{
XF86DRIDestroyDrawable(dri_screen->display, dri_screen->num, drawable);
free(dri_draw);
return 1;
}
/*
* XXX: Need this to initialize sarea pointer and other stuff in dri_drawable_t
* to be able to use the DRI_VALIDATE_DRAWABLE_INFO macro, but is it safe to
* call without any sync?
*/
if (driUpdateDrawableInfo(dri_draw))
{
XF86DRIDestroyDrawable(dri_screen->display, dri_screen->num, drawable);
free(dri_draw);
return 1;
}
*dri_drawable = dri_draw;
return 0;
}
int driUpdateDrawableInfo(dri_drawable_t *dri_drawable)
{
assert(dri_drawable);
if (dri_drawable->cliprects)
XFree(dri_drawable->cliprects);
if (dri_drawable->back_cliprects)
XFree(dri_drawable->back_cliprects);
DRM_SPINUNLOCK(&dri_drawable->dri_screen->sarea->drawable_lock, dri_drawable->dri_screen->draw_lock_id);
if (!XF86DRIGetDrawableInfo
(
dri_drawable->dri_screen->display,
dri_drawable->dri_screen->num,
dri_drawable->x_drawable,
&dri_drawable->sarea_index,
&dri_drawable->last_sarea_stamp,
&dri_drawable->x,
&dri_drawable->y,
&dri_drawable->w,
&dri_drawable->h,
&dri_drawable->num_cliprects,
&dri_drawable->cliprects,
&dri_drawable->back_x,
&dri_drawable->back_y,
&dri_drawable->num_back_cliprects,
&dri_drawable->back_cliprects
))
{
dri_drawable->sarea_stamp = &dri_drawable->last_sarea_stamp;
dri_drawable->num_cliprects = 0;
dri_drawable->cliprects = NULL;
dri_drawable->num_back_cliprects = 0;
dri_drawable->back_cliprects = 0;
return 1;
}
else
dri_drawable->sarea_stamp = &dri_drawable->dri_screen->sarea->drawableTable[dri_drawable->sarea_index].stamp;
DRM_SPINLOCK(&dri_drawable->dri_screen->sarea->drawable_lock, dri_drawable->dri_screen->draw_lock_id);
return 0;
}
int driDestroyDrawable(dri_drawable_t *dri_drawable)
{
assert(dri_drawable);
if (--dri_drawable->refcount == 0)
{
if (dri_drawable->cliprects)
XFree(dri_drawable->cliprects);
if (dri_drawable->back_cliprects)
XFree(dri_drawable->back_cliprects);
drmHashDelete(dri_drawable->dri_screen->drawable_hash, dri_drawable->x_drawable);
XF86DRIDestroyDrawable(dri_drawable->dri_screen->display, dri_drawable->dri_screen->num, dri_drawable->x_drawable);
free(dri_drawable);
}
return 0;
}
int driCreateContext(dri_screen_t *dri_screen, Visual *visual, dri_context_t **dri_context)
{
int evbase, errbase;
dri_context_t *dri_ctx;
assert(dri_screen);
assert(visual);
assert(dri_context);
if (!XF86DRIQueryExtension(dri_screen->display, &evbase, &errbase))
return 1;
dri_ctx = calloc(1, sizeof(dri_context_t));
if (!dri_ctx)
return 1;
if (!XF86DRICreateContext(dri_screen->display, dri_screen->num, visual, &dri_ctx->id, &dri_ctx->drm_context))
{
free(dri_ctx);
return 1;
}
dri_ctx->dri_screen = dri_screen;
*dri_context = dri_ctx;
return 0;
}
int driDestroyContext(dri_context_t *dri_context)
{
assert(dri_context);
XF86DRIDestroyContext(dri_context->dri_screen->display, dri_context->dri_screen->num, dri_context->id);
free(dri_context);
return 0;
}
int driCompareVersions(const dri_version_t *v1, const dri_version_t *v2)
{
return (v1->major == v2->major) && (v1->minor == v2->minor) && (v1->patch == v2->patch);
}
src/driclient/src/test
Executable
BIN
View File
Binary file not shown.
src/driclient/src/test.c
+41
View File
@@ -0,0 +1,41 @@
#include <assert.h>
#include <stdio.h>
#include "driclient.h"
int main(int argc, char **argv)
{
Display *dpy;
Window root, window;
dri_screen_t *screen;
dri_drawable_t *dri_drawable;
dri_context_t *context;
dpy = XOpenDisplay(NULL);
root = XDefaultRootWindow(dpy);
window = XCreateSimpleWindow(dpy, root, 0, 0, 100, 100, 0, 0, 0);
XSelectInput(dpy, window, 0);
XMapWindow(dpy, window);
XSync(dpy, 0);
assert(driCreateScreen(dpy, 0, &screen, NULL) == 0);
assert(driCreateDrawable(screen, window, &dri_drawable) == 0);
assert(driCreateContext(screen, XDefaultVisual(dpy, 0), &context) == 0);
assert(driUpdateDrawableInfo(dri_drawable) == 0);
DRI_VALIDATE_DRAWABLE_INFO(screen, dri_drawable);
assert(drmGetLock(screen->fd, context->drm_context, 0) == 0);
assert(drmUnlock(screen->fd, context->drm_context) == 0);
assert(driDestroyContext(context) == 0);
assert(driDestroyDrawable(dri_drawable) == 0);
assert(driDestroyScreen(screen) == 0);
XDestroyWindow(dpy, window);
XCloseDisplay(dpy);
return 0;
}
src/driclient/src/xf86dri.h
+119
View File
@@ -0,0 +1,119 @@
/**************************************************************************
Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
Copyright 2000 VA Linux Systems, Inc.
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, sub license, 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 NON-INFRINGEMENT.
IN NO EVENT SHALL PRECISION INSIGHT 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.
**************************************************************************/
/**
* \file xf86dri.h
* Protocol numbers and function prototypes for DRI X protocol.
*
* \author Kevin E. Martin <martin@valinux.com>
* \author Jens Owen <jens@tungstengraphics.com>
* \author Rickard E. (Rik) Faith <faith@valinux.com>
*/
#ifndef _XF86DRI_H_
#define _XF86DRI_H_
#include <X11/Xfuncproto.h>
#include <xf86drm.h>
#define X_XF86DRIQueryVersion 0
#define X_XF86DRIQueryDirectRenderingCapable 1
#define X_XF86DRIOpenConnection 2
#define X_XF86DRICloseConnection 3
#define X_XF86DRIGetClientDriverName 4
#define X_XF86DRICreateContext 5
#define X_XF86DRIDestroyContext 6
#define X_XF86DRICreateDrawable 7
#define X_XF86DRIDestroyDrawable 8
#define X_XF86DRIGetDrawableInfo 9
#define X_XF86DRIGetDeviceInfo 10
#define X_XF86DRIAuthConnection 11
#define X_XF86DRIOpenFullScreen 12 /* Deprecated */
#define X_XF86DRICloseFullScreen 13 /* Deprecated */
#define XF86DRINumberEvents 0
#define XF86DRIClientNotLocal 0
#define XF86DRIOperationNotSupported 1
#define XF86DRINumberErrors (XF86DRIOperationNotSupported + 1)
#ifndef _XF86DRI_SERVER_
_XFUNCPROTOBEGIN
Bool XF86DRIQueryExtension( Display *dpy, int *event_base, int *error_base );
Bool XF86DRIQueryVersion( Display *dpy, int *majorVersion, int *minorVersion,
int *patchVersion );
Bool XF86DRIQueryDirectRenderingCapable( Display *dpy, int screen,
Bool *isCapable );
Bool XF86DRIOpenConnection( Display *dpy, int screen, drm_handle_t *hSAREA,
char **busIDString );
Bool XF86DRIAuthConnection( Display *dpy, int screen, drm_magic_t magic );
Bool XF86DRICloseConnection( Display *dpy, int screen );
Bool XF86DRIGetClientDriverName( Display *dpy, int screen,
int *ddxDriverMajorVersion, int *ddxDriverMinorVersion,
int *ddxDriverPatchVersion, char **clientDriverName );
Bool XF86DRICreateContext( Display *dpy, int screen, Visual *visual,
XID *ptr_to_returned_context_id, drm_context_t *hHWContext );
Bool XF86DRICreateContextWithConfig( Display *dpy, int screen, int configID,
XID *ptr_to_returned_context_id, drm_context_t *hHWContext );
Bool XF86DRIDestroyContext( Display *dpy, int screen,
XID context_id );
Bool XF86DRICreateDrawable( Display *dpy, int screen,
Drawable drawable, drm_drawable_t *hHWDrawable );
Bool XF86DRIDestroyDrawable( Display *dpy, int screen,
Drawable drawable);
Bool XF86DRIGetDrawableInfo( Display *dpy, int screen, Drawable drawable,
unsigned int *index, unsigned int *stamp,
int *X, int *Y, int *W, int *H,
int *numClipRects, drm_clip_rect_t ** pClipRects,
int *backX, int *backY,
int *numBackClipRects, drm_clip_rect_t **pBackClipRects );
Bool XF86DRIGetDeviceInfo( Display *dpy, int screen,
drm_handle_t *hFrameBuffer, int *fbOrigin, int *fbSize,
int *fbStride, int *devPrivateSize, void **pDevPrivate );
_XFUNCPROTOEND
#endif /* _XF86DRI_SERVER_ */
#endif /* _XF86DRI_H_ */
src/driclient/src/xf86dristr.h
+342
View File
@@ -0,0 +1,342 @@
/**************************************************************************
Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
Copyright 2000 VA Linux Systems, Inc.
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, sub license, 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 NON-INFRINGEMENT.
IN NO EVENT SHALL PRECISION INSIGHT 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:
* Kevin E. Martin <martin@valinux.com>
* Jens Owen <jens@tungstengraphics.com>
* Rickard E. (Rik) Fiath <faith@valinux.com>
*
*/
#ifndef _XF86DRISTR_H_
#define _XF86DRISTR_H_
#include "xf86dri.h"
#define XF86DRINAME "XFree86-DRI"
/* The DRI version number. This was originally set to be the same of the
* XFree86 version number. However, this version is really indepedent of
* the XFree86 version.
*
* Version History:
* 4.0.0: Original
* 4.0.1: Patch to bump clipstamp when windows are destroyed, 28 May 02
* 4.1.0: Add transition from single to multi in DRMInfo rec, 24 Jun 02
*/
#define XF86DRI_MAJOR_VERSION 4
#define XF86DRI_MINOR_VERSION 1
#define XF86DRI_PATCH_VERSION 0
typedef struct _XF86DRIQueryVersion {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRIQueryVersion */
CARD16 length B16;
} xXF86DRIQueryVersionReq;
#define sz_xXF86DRIQueryVersionReq 4
typedef struct {
BYTE type; /* X_Reply */
BOOL pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD16 majorVersion B16; /* major version of DRI protocol */
CARD16 minorVersion B16; /* minor version of DRI protocol */
CARD32 patchVersion B32; /* patch version of DRI protocol */
CARD32 pad3 B32;
CARD32 pad4 B32;
CARD32 pad5 B32;
CARD32 pad6 B32;
} xXF86DRIQueryVersionReply;
#define sz_xXF86DRIQueryVersionReply 32
typedef struct _XF86DRIQueryDirectRenderingCapable {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* X_DRIQueryDirectRenderingCapable */
CARD16 length B16;
CARD32 screen B32;
} xXF86DRIQueryDirectRenderingCapableReq;
#define sz_xXF86DRIQueryDirectRenderingCapableReq 8
typedef struct {
BYTE type; /* X_Reply */
BOOL pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
BOOL isCapable;
BOOL pad2;
BOOL pad3;
BOOL pad4;
CARD32 pad5 B32;
CARD32 pad6 B32;
CARD32 pad7 B32;
CARD32 pad8 B32;
CARD32 pad9 B32;
} xXF86DRIQueryDirectRenderingCapableReply;
#define sz_xXF86DRIQueryDirectRenderingCapableReply 32
typedef struct _XF86DRIOpenConnection {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRIOpenConnection */
CARD16 length B16;
CARD32 screen B32;
} xXF86DRIOpenConnectionReq;
#define sz_xXF86DRIOpenConnectionReq 8
typedef struct {
BYTE type; /* X_Reply */
BOOL pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 hSAREALow B32;
CARD32 hSAREAHigh B32;
CARD32 busIdStringLength B32;
CARD32 pad6 B32;
CARD32 pad7 B32;
CARD32 pad8 B32;
} xXF86DRIOpenConnectionReply;
#define sz_xXF86DRIOpenConnectionReply 32
typedef struct _XF86DRIAuthConnection {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRICloseConnection */
CARD16 length B16;
CARD32 screen B32;
CARD32 magic B32;
} xXF86DRIAuthConnectionReq;
#define sz_xXF86DRIAuthConnectionReq 12
typedef struct {
BYTE type;
BOOL pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 authenticated B32;
CARD32 pad2 B32;
CARD32 pad3 B32;
CARD32 pad4 B32;
CARD32 pad5 B32;
CARD32 pad6 B32;
} xXF86DRIAuthConnectionReply;
#define zx_xXF86DRIAuthConnectionReply 32
typedef struct _XF86DRICloseConnection {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRICloseConnection */
CARD16 length B16;
CARD32 screen B32;
} xXF86DRICloseConnectionReq;
#define sz_xXF86DRICloseConnectionReq 8
typedef struct _XF86DRIGetClientDriverName {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRIGetClientDriverName */
CARD16 length B16;
CARD32 screen B32;
} xXF86DRIGetClientDriverNameReq;
#define sz_xXF86DRIGetClientDriverNameReq 8
typedef struct {
BYTE type; /* X_Reply */
BOOL pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 ddxDriverMajorVersion B32;
CARD32 ddxDriverMinorVersion B32;
CARD32 ddxDriverPatchVersion B32;
CARD32 clientDriverNameLength B32;
CARD32 pad5 B32;
CARD32 pad6 B32;
} xXF86DRIGetClientDriverNameReply;
#define sz_xXF86DRIGetClientDriverNameReply 32
typedef struct _XF86DRICreateContext {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRICreateContext */
CARD16 length B16;
CARD32 screen B32;
CARD32 visual B32;
CARD32 context B32;
} xXF86DRICreateContextReq;
#define sz_xXF86DRICreateContextReq 16
typedef struct {
BYTE type; /* X_Reply */
BOOL pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 hHWContext B32;
CARD32 pad2 B32;
CARD32 pad3 B32;
CARD32 pad4 B32;
CARD32 pad5 B32;
CARD32 pad6 B32;
} xXF86DRICreateContextReply;
#define sz_xXF86DRICreateContextReply 32
typedef struct _XF86DRIDestroyContext {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRIDestroyContext */
CARD16 length B16;
CARD32 screen B32;
CARD32 context B32;
} xXF86DRIDestroyContextReq;
#define sz_xXF86DRIDestroyContextReq 12
typedef struct _XF86DRICreateDrawable {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRICreateDrawable */
CARD16 length B16;
CARD32 screen B32;
CARD32 drawable B32;
} xXF86DRICreateDrawableReq;
#define sz_xXF86DRICreateDrawableReq 12
typedef struct {
BYTE type; /* X_Reply */
BOOL pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 hHWDrawable B32;
CARD32 pad2 B32;
CARD32 pad3 B32;
CARD32 pad4 B32;
CARD32 pad5 B32;
CARD32 pad6 B32;
} xXF86DRICreateDrawableReply;
#define sz_xXF86DRICreateDrawableReply 32
typedef struct _XF86DRIDestroyDrawable {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRIDestroyDrawable */
CARD16 length B16;
CARD32 screen B32;
CARD32 drawable B32;
} xXF86DRIDestroyDrawableReq;
#define sz_xXF86DRIDestroyDrawableReq 12
typedef struct _XF86DRIGetDrawableInfo {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRIGetDrawableInfo */
CARD16 length B16;
CARD32 screen B32;
CARD32 drawable B32;
} xXF86DRIGetDrawableInfoReq;
#define sz_xXF86DRIGetDrawableInfoReq 12
typedef struct {
BYTE type; /* X_Reply */
BOOL pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 drawableTableIndex B32;
CARD32 drawableTableStamp B32;
INT16 drawableX B16;
INT16 drawableY B16;
INT16 drawableWidth B16;
INT16 drawableHeight B16;
CARD32 numClipRects B32;
INT16 backX B16;
INT16 backY B16;
CARD32 numBackClipRects B32;
} xXF86DRIGetDrawableInfoReply;
#define sz_xXF86DRIGetDrawableInfoReply 36
typedef struct _XF86DRIGetDeviceInfo {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRIGetDeviceInfo */
CARD16 length B16;
CARD32 screen B32;
} xXF86DRIGetDeviceInfoReq;
#define sz_xXF86DRIGetDeviceInfoReq 8
typedef struct {
BYTE type; /* X_Reply */
BOOL pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 hFrameBufferLow B32;
CARD32 hFrameBufferHigh B32;
CARD32 framebufferOrigin B32;
CARD32 framebufferSize B32;
CARD32 framebufferStride B32;
CARD32 devPrivateSize B32;
} xXF86DRIGetDeviceInfoReply;
#define sz_xXF86DRIGetDeviceInfoReply 32
typedef struct _XF86DRIOpenFullScreen {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRIOpenFullScreen */
CARD16 length B16;
CARD32 screen B32;
CARD32 drawable B32;
} xXF86DRIOpenFullScreenReq;
#define sz_xXF86DRIOpenFullScreenReq 12
typedef struct {
BYTE type;
BOOL pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 isFullScreen B32;
CARD32 pad2 B32;
CARD32 pad3 B32;
CARD32 pad4 B32;
CARD32 pad5 B32;
CARD32 pad6 B32;
} xXF86DRIOpenFullScreenReply;
#define sz_xXF86DRIOpenFullScreenReply 32
typedef struct _XF86DRICloseFullScreen {
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRICloseFullScreen */
CARD16 length B16;
CARD32 screen B32;
CARD32 drawable B32;
} xXF86DRICloseFullScreenReq;
#define sz_xXF86DRICloseFullScreenReq 12
typedef struct {
BYTE type;
BOOL pad1;
CARD16 sequenceNumber B16;
CARD32 length B32;
CARD32 pad2 B32;
CARD32 pad3 B32;
CARD32 pad4 B32;
CARD32 pad5 B32;
CARD32 pad6 B32;
CARD32 pad7 B32;
} xXF86DRICloseFullScreenReply;
#define sz_xXF86DRICloseFullScreenReply 32
#endif /* _XF86DRISTR_H_ */
src/gallium/state_trackers/g3dvl/Makefile
+1 -1
View File
@@ -2,7 +2,7 @@ TARGET = libg3dvl.a
OBJECTS = vl_context.o vl_data.o vl_surface.o vl_shader_build.o vl_util.o
GALLIUMDIR = ../..
CFLAGS += -g -Wall -fPIC -Werror -I${GALLIUMDIR}/include -I${GALLIUMDIR}/auxiliary
CFLAGS += -g -Wall -fPIC -Werror -I${GALLIUMDIR}/include -I${GALLIUMDIR}/auxiliary -I${GALLIUMDIR}/winsys/g3dvl
#############################################
src/gallium/state_trackers/g3dvl/vl_context.c
+56 -12
View File
@@ -330,6 +330,10 @@ static int vlCreateVertexShaderIMC(struct VL_CONTEXT *context)
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
/* decl t0 */
decl = vl_decl_temps(0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* mul t0, i0, c0 ; Scale unit rect to normalized MB size */
inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_INPUT, 0, TGSI_FILE_CONSTANT, 0);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
@@ -354,7 +358,7 @@ static int vlCreateVertexShaderIMC(struct VL_CONTEXT *context)
vs.tokens = tokens;
context->states.mc.i_vs = pipe->create_vs_state(pipe, &vs);
free(tokens);
//free(tokens);
return 0;
}
@@ -432,7 +436,7 @@ static int vlCreateFragmentShaderIMC(struct VL_CONTEXT *context)
fs.tokens = tokens;
context->states.mc.i_fs = pipe->create_fs_state(pipe, &fs);
free(tokens);
//free(tokens);
return 0;
}
@@ -499,6 +503,10 @@ static int vlCreateVertexShaderFramePMC(struct VL_CONTEXT *context)
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
/* decl t0 */
decl = vl_decl_temps(0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* mul t0, i0, c0 ; Scale unit rect to normalized MB size */
inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_INPUT, 0, TGSI_FILE_CONSTANT, 0);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
@@ -527,7 +535,7 @@ static int vlCreateVertexShaderFramePMC(struct VL_CONTEXT *context)
vs.tokens = tokens;
context->states.mc.p_vs[0] = pipe->create_vs_state(pipe, &vs);
free(tokens);
//free(tokens);
return 0;
}
@@ -603,6 +611,10 @@ static int vlCreateVertexShaderFieldPMC(struct VL_CONTEXT *context)
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
/* decl t0, t1 */
decl = vl_decl_temps(0, 1);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* mul t0, i0, c0 ; Scale unit rect to normalized MB size */
inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_INPUT, 0, TGSI_FILE_CONSTANT, 0);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
@@ -643,7 +655,7 @@ static int vlCreateVertexShaderFieldPMC(struct VL_CONTEXT *context)
vs.tokens = tokens;
context->states.mc.p_vs[1] = pipe->create_vs_state(pipe, &vs);
free(tokens);
//free(tokens);
return 0;
}
@@ -700,6 +712,10 @@ static int vlCreateFragmentShaderFramePMC(struct VL_CONTEXT *context)
decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* decl t0, t1 */
decl = vl_decl_temps(0, 1);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/*
* decl s0 ; Sampler for luma texture
* decl s1 ; Sampler for chroma Cb texture
@@ -761,7 +777,7 @@ static int vlCreateFragmentShaderFramePMC(struct VL_CONTEXT *context)
fs.tokens = tokens;
context->states.mc.p_fs[0] = pipe->create_fs_state(pipe, &fs);
free(tokens);
//free(tokens);
return 0;
}
@@ -821,6 +837,10 @@ static int vlCreateFragmentShaderFieldPMC(struct VL_CONTEXT *context)
decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* decl t0-t4 */
decl = vl_decl_temps(0, 4);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/*
* decl s0 ; Sampler for luma texture
* decl s1 ; Sampler for chroma Cb texture
@@ -928,7 +948,7 @@ static int vlCreateFragmentShaderFieldPMC(struct VL_CONTEXT *context)
fs.tokens = tokens;
context->states.mc.p_fs[1] = pipe->create_fs_state(pipe, &fs);
free(tokens);
//free(tokens);
return 0;
}
@@ -998,6 +1018,10 @@ static int vlCreateVertexShaderFrameBMC(struct VL_CONTEXT *context)
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
/* decl t0 */
decl = vl_decl_temps(0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* mul t0, i0, c0 ; Scale unit rect to normalized MB size */
inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_INPUT, 0, TGSI_FILE_CONSTANT, 0);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
@@ -1030,7 +1054,7 @@ static int vlCreateVertexShaderFrameBMC(struct VL_CONTEXT *context)
vs.tokens = tokens;
context->states.mc.b_vs[0] = pipe->create_vs_state(pipe, &vs);
free(tokens);
//free(tokens);
return 0;
}
@@ -1104,6 +1128,10 @@ static int vlCreateVertexShaderFieldBMC(struct VL_CONTEXT *context)
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
/* decl t0, t1 */
decl = vl_decl_temps(0, 1);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* mul t0, i0, c0 ; Scale unit rect to normalized MB size */
inst = vl_inst3(TGSI_OPCODE_MUL, TGSI_FILE_TEMPORARY, 0, TGSI_FILE_INPUT, 0, TGSI_FILE_CONSTANT, 0);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
@@ -1148,7 +1176,7 @@ static int vlCreateVertexShaderFieldBMC(struct VL_CONTEXT *context)
vs.tokens = tokens;
context->states.mc.b_vs[1] = pipe->create_vs_state(pipe, &vs);
free(tokens);
//free(tokens);
return 0;
}
@@ -1207,6 +1235,10 @@ static int vlCreateFragmentShaderFrameBMC(struct VL_CONTEXT *context)
decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* decl t0-t2 */
decl = vl_decl_temps(0, 2);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/*
* decl s0 ; Sampler for luma texture
* decl s1 ; Sampler for chroma Cb texture
@@ -1283,7 +1315,7 @@ static int vlCreateFragmentShaderFrameBMC(struct VL_CONTEXT *context)
fs.tokens = tokens;
context->states.mc.b_fs[0] = pipe->create_fs_state(pipe, &fs);
free(tokens);
//free(tokens);
return 0;
}
@@ -1346,6 +1378,10 @@ static int vlCreateFragmentShaderFieldBMC(struct VL_CONTEXT *context)
decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* decl t0-t5 */
decl = vl_decl_temps(0, 5);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/*
* decl s0 ; Sampler for luma texture
* decl s1 ; Sampler for chroma Cb texture
@@ -1479,7 +1515,7 @@ static int vlCreateFragmentShaderFieldBMC(struct VL_CONTEXT *context)
fs.tokens = tokens;
context->states.mc.b_fs[1] = pipe->create_fs_state(pipe, &fs);
free(tokens);
//free(tokens);
return 0;
}
@@ -1771,6 +1807,10 @@ static int vlCreateVertexShaderCSC(struct VL_CONTEXT *context)
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
}
/* decl t0 */
decl = vl_decl_temps(0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* mov o0, i0 ; Move pos in to pos out */
inst = vl_inst2(TGSI_OPCODE_MOV, TGSI_FILE_OUTPUT, 0, TGSI_FILE_INPUT, 0);
ti += tgsi_build_full_instruction(&inst, &tokens[ti], header, max_tokens - ti);
@@ -1789,7 +1829,7 @@ static int vlCreateVertexShaderCSC(struct VL_CONTEXT *context)
vs.tokens = tokens;
context->states.csc.vertex_shader = pipe->create_vs_state(pipe, &vs);
free(tokens);
//free(tokens);
return 0;
}
@@ -1839,6 +1879,10 @@ static int vlCreateFragmentShaderCSC(struct VL_CONTEXT *context)
decl = vl_decl_output(TGSI_SEMANTIC_COLOR, 0, 0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* decl t0 */
decl = vl_decl_temps(0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
/* decl s0 ; Sampler for tex containing picture to display */
decl = vl_decl_samplers(0, 0);
ti += tgsi_build_full_declaration(&decl, &tokens[ti], header, max_tokens - ti);
@@ -1870,7 +1914,7 @@ static int vlCreateFragmentShaderCSC(struct VL_CONTEXT *context)
fs.tokens = tokens;
context->states.csc.fragment_shader = pipe->create_fs_state(pipe, &fs);
free(tokens);
//free(tokens);
return 0;
}
src/gallium/state_trackers/g3dvl/vl_shader_build.c
+12
View File
@@ -74,6 +74,18 @@ struct tgsi_full_declaration vl_decl_output(unsigned int name, unsigned int inde
return decl;
}
struct tgsi_full_declaration vl_decl_temps(unsigned int first, unsigned int last)
{
struct tgsi_full_declaration decl = tgsi_default_full_declaration();
decl = tgsi_default_full_declaration();
decl.Declaration.File = TGSI_FILE_TEMPORARY;
decl.DeclarationRange.First = first;
decl.DeclarationRange.Last = last;
return decl;
}
struct tgsi_full_declaration vl_decl_samplers(unsigned int first, unsigned int last)
{
struct tgsi_full_declaration decl = tgsi_default_full_declaration();
src/gallium/state_trackers/g3dvl/vl_shader_build.h
+1
View File
@@ -14,6 +14,7 @@ struct tgsi_full_declaration vl_decl_interpolated_input
);
struct tgsi_full_declaration vl_decl_constants(unsigned int name, unsigned int index, unsigned int first, unsigned int last);
struct tgsi_full_declaration vl_decl_output(unsigned int name, unsigned int index, unsigned int first, unsigned int last);
struct tgsi_full_declaration vl_decl_temps(unsigned int first, unsigned int last);
struct tgsi_full_declaration vl_decl_samplers(unsigned int first, unsigned int last);
struct tgsi_full_instruction vl_inst2
(
src/gallium/state_trackers/g3dvl/vl_surface.c
+3 -1
View File
@@ -5,6 +5,7 @@
#include <pipe/p_state.h>
#include <pipe/p_format.h>
#include <pipe/p_inlines.h>
#include <vl_winsys.h>
#include "vl_context.h"
#include "vl_defs.h"
#include "vl_util.h"
@@ -711,12 +712,13 @@ int vlPutSurface
pipe->set_sampler_textures(pipe, 1, &surface->texture);
pipe->draw_arrays(pipe, PIPE_PRIM_TRIANGLE_STRIP, 0, 4);
pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
bind_pipe_drawable(pipe, drawable);
/* TODO: Need to take destx, desty into consideration */
pipe->winsys->flush_frontbuffer
(
pipe->winsys,
surface->context->states.csc.framebuffer.cbufs[0],
&drawable
pipe->priv
);
vlBeginRender(surface->context);
src/gallium/winsys/g3dvl/nouveau/Makefile
+46
View File
@@ -0,0 +1,46 @@
TARGET = libnouveau_dri.so
GALLIUMDIR = ../../..
DRMDIR ?= /usr
DRIDIR = ../../../../driclient
OBJECTS = nouveau_bo.o nouveau_fence.o nouveau_swapbuffers.o nouveau_channel.o \
nouveau_grobj.o nouveau_context.o nouveau_winsys.o nouveau_lock.o \
nouveau_winsys_pipe.o nouveau_device.o nouveau_notifier.o nouveau_dma.o \
nouveau_pushbuf.o nouveau_resource.o nouveau_screen.o nv04_surface.o \
nv50_surface.o #nouveau_winsys_softpipe.o
CFLAGS += -g -Wall -Werror -fPIC \
-I${GALLIUMDIR}/include \
-I${GALLIUMDIR}/winsys/g3dvl \
-I${DRMDIR}/include \
-I${DRMDIR}/include/drm \
-I${GALLIUMDIR}/drivers \
-I${GALLIUMDIR}/auxiliary \
-I${DRIDIR}/include
LDFLAGS += -L${DRMDIR}/lib \
-L${DRIDIR}/lib \
-L${GALLIUMDIR}/auxiliary/draw \
-L${GALLIUMDIR}/auxiliary/tgsi \
-L${GALLIUMDIR}/auxiliary/translate \
-L${GALLIUMDIR}/auxiliary/rtasm \
-L${GALLIUMDIR}/auxiliary/cso_cache \
-L${GALLIUMDIR}/drivers/nv10 \
-L${GALLIUMDIR}/drivers/nv30 \
-L${GALLIUMDIR}/drivers/nv40 \
-L${GALLIUMDIR}/drivers/nv50
LIBS += -ldriclient -ldrm -lnv10 -lnv30 -lnv40 -lnv50 -ldraw -ltgsi -ltranslate -lrtasm -lcso_cache -lm
#############################################
.PHONY = all clean
all: ${TARGET}
${TARGET}: ${OBJECTS}
$(CC) ${LDFLAGS} -shared -o $@ $^ ${LIBS}
clean:
rm -rf ${OBJECTS} ${TARGET}
src/gallium/winsys/g3dvl/nouveau/nouveau_bo.c
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_bo.c
src/gallium/winsys/g3dvl/nouveau/nouveau_channel.c
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_channel.c
src/gallium/winsys/g3dvl/nouveau/nouveau_context.c
+371
View File
@@ -0,0 +1,371 @@
#include "pipe/p_defines.h"
#include "pipe/p_context.h"
#include "pipe/p_screen.h"
#include "pipe/p_util.h"
#include "nouveau_context.h"
#include "nouveau_dri.h"
#include "nouveau_local.h"
#include "nouveau_screen.h"
#include "nouveau_winsys_pipe.h"
/*
#ifdef DEBUG
static const struct dri_debug_control debug_control[] = {
{ "bo", DEBUG_BO },
{ NULL, 0 }
};
int __nouveau_debug = 0;
#endif
*/
/*
* TODO: Re-examine dri_screen, dri_context, nouveau_screen, nouveau_context
* relationships, seems like there is a lot of room for simplification there.
*/
static void
nouveau_channel_context_destroy(struct nouveau_channel_context *nvc)
{
nouveau_grobj_free(&nvc->NvCtxSurf2D);
nouveau_grobj_free(&nvc->NvImageBlit);
nouveau_grobj_free(&nvc->NvGdiRect);
nouveau_grobj_free(&nvc->NvM2MF);
nouveau_grobj_free(&nvc->Nv2D);
nouveau_grobj_free(&nvc->NvSwzSurf);
nouveau_grobj_free(&nvc->NvSIFM);
nouveau_notifier_free(&nvc->sync_notifier);
nouveau_channel_free(&nvc->channel);
FREE(nvc);
}
static struct nouveau_channel_context *
nouveau_channel_context_create(struct nouveau_device *dev)
{
struct nouveau_channel_context *nvc;
int ret;
nvc = CALLOC_STRUCT(nouveau_channel_context);
if (!nvc)
return NULL;
if ((ret = nouveau_channel_alloc(dev, 0x8003d001, 0x8003d002,
&nvc->channel))) {
NOUVEAU_ERR("Error creating GPU channel: %d\n", ret);
nouveau_channel_context_destroy(nvc);
return NULL;
}
nvc->next_handle = 0x80000000;
if ((ret = nouveau_notifier_alloc(nvc->channel, nvc->next_handle++, 1,
&nvc->sync_notifier))) {
NOUVEAU_ERR("Error creating channel sync notifier: %d\n", ret);
nouveau_channel_context_destroy(nvc);
return NULL;
}
switch (dev->chipset & 0xf0) {
case 0x50:
case 0x80:
case 0x90:
ret = nouveau_surface_channel_create_nv50(nvc);
break;
default:
ret = nouveau_surface_channel_create_nv04(nvc);
break;
}
if (ret) {
NOUVEAU_ERR("Error initialising surface objects: %d\n", ret);
nouveau_channel_context_destroy(nvc);
return NULL;
}
return nvc;
}
int
nouveau_context_create(dri_context_t *dri_context)
{
dri_screen_t *dri_screen = dri_context->dri_screen;
struct nouveau_screen *nv_screen = dri_screen->private;
struct nouveau_context *nv = CALLOC_STRUCT(nouveau_context);
struct pipe_context *pipe = NULL;
struct nouveau_channel_context *nvc = NULL;
struct nouveau_device *dev = nv_screen->device;
int i;
switch (dev->chipset & 0xf0) {
case 0x10:
case 0x20:
/* NV10 */
case 0x30:
/* NV30 */
case 0x40:
case 0x60:
/* NV40 */
case 0x50:
case 0x80:
case 0x90:
/* G80 */
break;
default:
NOUVEAU_ERR("Unsupported chipset: NV%02x\n", dev->chipset);
return 1;
}
dri_context->private = (void*)nv;
nv->dri_context = dri_context;
nv->nv_screen = nv_screen;
{
struct nouveau_device_priv *nvdev = nouveau_device(dev);
nvdev->ctx = dri_context->drm_context;
nvdev->lock = (drmLock*)&dri_screen->sarea->lock;
}
/*
driParseConfigFiles(&nv->dri_option_cache, &nv_screen->option_cache,
nv->dri_screen->myNum, "nouveau");
#ifdef DEBUG
__nouveau_debug = driParseDebugString(getenv("NOUVEAU_DEBUG"),
debug_control);
#endif
*/
/*XXX: Hack up a fake region and buffer object for front buffer.
* This will go away with TTM, replaced with a simple reference
* of the front buffer handle passed to us by the DDX.
*/
{
struct pipe_surface *fb_surf;
struct nouveau_pipe_buffer *fb_buf;
struct nouveau_bo_priv *fb_bo;
fb_bo = calloc(1, sizeof(struct nouveau_bo_priv));
fb_bo->drm.offset = nv_screen->front_offset;
fb_bo->drm.flags = NOUVEAU_MEM_FB;
fb_bo->drm.size = nv_screen->front_pitch *
nv_screen->front_height;
fb_bo->refcount = 1;
fb_bo->base.flags = NOUVEAU_BO_PIN | NOUVEAU_BO_VRAM;
fb_bo->base.offset = fb_bo->drm.offset;
fb_bo->base.handle = (unsigned long)fb_bo;
fb_bo->base.size = fb_bo->drm.size;
fb_bo->base.device = nv_screen->device;
fb_buf = calloc(1, sizeof(struct nouveau_pipe_buffer));
fb_buf->bo = &fb_bo->base;
fb_surf = calloc(1, sizeof(struct pipe_surface));
if (nv_screen->front_cpp == 2)
fb_surf->format = PIPE_FORMAT_R5G6B5_UNORM;
else
fb_surf->format = PIPE_FORMAT_A8R8G8B8_UNORM;
pf_get_block(fb_surf->format, &fb_surf->block);
fb_surf->width = nv_screen->front_pitch / nv_screen->front_cpp;
fb_surf->height = nv_screen->front_height;
fb_surf->stride = fb_surf->width * fb_surf->block.size;
fb_surf->refcount = 1;
fb_surf->buffer = &fb_buf->base;
nv->frontbuffer = fb_surf;
}
nvc = nv_screen->nvc;
if (!nvc) {
nvc = nouveau_channel_context_create(dev);
if (!nvc) {
NOUVEAU_ERR("Failed initialising GPU context\n");
return 1;
}
nv_screen->nvc = nvc;
}
nvc->refcount++;
nv->nvc = nvc;
/* Find a free slot for a pipe context, allocate a new one if needed */
nv->pctx_id = -1;
for (i = 0; i < nvc->nr_pctx; i++) {
if (nvc->pctx[i] == NULL) {
nv->pctx_id = i;
break;
}
}
if (nv->pctx_id < 0) {
nv->pctx_id = nvc->nr_pctx++;
nvc->pctx =
realloc(nvc->pctx,
sizeof(struct pipe_context *) * nvc->nr_pctx);
}
/* Create pipe */
switch (dev->chipset & 0xf0) {
case 0x50:
case 0x80:
case 0x90:
if (nouveau_surface_init_nv50(nv))
return 1;
break;
default:
if (nouveau_surface_init_nv04(nv))
return 1;
break;
}
if (!getenv("NOUVEAU_FORCE_SOFTPIPE")) {
struct pipe_screen *pscreen;
pipe = nouveau_pipe_create(nv);
if (!pipe)
NOUVEAU_ERR("Couldn't create hw pipe\n");
pscreen = nvc->pscreen;
nv->cap.hw_vertex_buffer =
pscreen->get_param(pscreen, NOUVEAU_CAP_HW_VTXBUF);
nv->cap.hw_index_buffer =
pscreen->get_param(pscreen, NOUVEAU_CAP_HW_IDXBUF);
}
/* XXX: nouveau_winsys_softpipe needs a mesa header removed before we can compile it. */
/*
if (!pipe) {
NOUVEAU_MSG("Using softpipe\n");
pipe = nouveau_create_softpipe(nv);
if (!pipe) {
NOUVEAU_ERR("Error creating pipe, bailing\n");
return 1;
}
}
*/
if (!pipe) {
NOUVEAU_ERR("Error creating pipe, bailing\n");
return 1;
}
pipe->priv = nv;
return 0;
}
void
nouveau_context_destroy(dri_context_t *dri_context)
{
struct nouveau_context *nv = dri_context->private;
struct nouveau_channel_context *nvc = nv->nvc;
assert(nv);
if (nv->pctx_id >= 0) {
nvc->pctx[nv->pctx_id] = NULL;
if (--nvc->refcount <= 0) {
nouveau_channel_context_destroy(nvc);
nv->nv_screen->nvc = NULL;
}
}
free(nv);
}
int
nouveau_context_bind(struct nouveau_context *nv, dri_drawable_t *dri_drawable)
{
assert(nv);
assert(dri_drawable);
if (nv->dri_drawable != dri_drawable)
{
nv->dri_drawable = dri_drawable;
dri_drawable->private = nv;
}
return 0;
}
int
nouveau_context_unbind(struct nouveau_context *nv)
{
assert(nv);
nv->dri_drawable = NULL;
return 0;
}
/* Show starts here */
int bind_pipe_drawable(struct pipe_context *pipe, Drawable drawable)
{
struct nouveau_context *nv;
dri_drawable_t *dri_drawable;
nv = pipe->priv;
driCreateDrawable(nv->nv_screen->dri_screen, drawable, &dri_drawable);
nouveau_context_bind(nv, dri_drawable);
return 0;
}
int unbind_pipe_drawable(struct pipe_context *pipe)
{
nouveau_context_unbind(pipe->priv);
return 0;
}
struct pipe_context* create_pipe_context(Display *display, int screen)
{
dri_screen_t *dri_screen;
dri_framebuffer_t dri_framebuf;
dri_context_t *dri_context;
struct nouveau_context *nv;
driCreateScreen(display, screen, &dri_screen, &dri_framebuf);
driCreateContext(dri_screen, XDefaultVisual(display, screen), &dri_context);
nouveau_screen_create(dri_screen, &dri_framebuf);
nouveau_context_create(dri_context);
nv = dri_context->private;
return nv->nvc->pctx[nv->pctx_id];
}
int destroy_pipe_context(struct pipe_context *pipe)
{
struct pipe_screen *screen;
struct pipe_winsys *winsys;
struct nouveau_context *nv;
dri_screen_t *dri_screen;
dri_context_t *dri_context;
assert(pipe);
screen = pipe->screen;
winsys = pipe->winsys;
nv = pipe->priv;
dri_context = nv->dri_context;
dri_screen = dri_context->dri_screen;
pipe->destroy(pipe);
screen->destroy(screen);
free(winsys);
nouveau_context_destroy(dri_context);
nouveau_screen_destroy(dri_screen);
driDestroyContext(dri_context);
driDestroyScreen(dri_screen);
return 0;
}
src/gallium/winsys/g3dvl/nouveau/nouveau_context.h
+105
View File
@@ -0,0 +1,105 @@
#ifndef __NOUVEAU_CONTEXT_H__
#define __NOUVEAU_CONTEXT_H__
/*#include "xmlconfig.h"*/
#include <driclient.h>
#include "nouveau/nouveau_winsys.h"
#include "nouveau_drmif.h"
#include "nouveau_dma.h"
struct nouveau_channel_context {
struct pipe_screen *pscreen;
int refcount;
unsigned cur_pctx;
unsigned nr_pctx;
struct pipe_context **pctx;
struct nouveau_channel *channel;
struct nouveau_notifier *sync_notifier;
/* Common */
struct nouveau_grobj *NvM2MF;
/* NV04-NV40 */
struct nouveau_grobj *NvCtxSurf2D;
struct nouveau_grobj *NvSwzSurf;
struct nouveau_grobj *NvImageBlit;
struct nouveau_grobj *NvGdiRect;
struct nouveau_grobj *NvSIFM;
/* G80 */
struct nouveau_grobj *Nv2D;
uint32_t next_handle;
uint32_t next_subchannel;
uint32_t next_sequence;
};
struct nouveau_context {
/* DRI stuff */
dri_context_t *dri_context;
dri_drawable_t *dri_drawable;
unsigned int last_stamp;
/*driOptionCache dri_option_cache;*/
drm_context_t drm_context;
drmLock drm_lock;
int locked;
struct nouveau_screen *nv_screen;
struct pipe_surface *frontbuffer;
struct {
int hw_vertex_buffer;
int hw_index_buffer;
} cap;
/* Hardware context */
struct nouveau_channel_context *nvc;
int pctx_id;
/* pipe_surface accel */
struct pipe_surface *surf_src, *surf_dst;
unsigned surf_src_offset, surf_dst_offset;
int (*surface_copy_prep)(struct nouveau_context *,
struct pipe_surface *dst,
struct pipe_surface *src);
void (*surface_copy)(struct nouveau_context *, unsigned dx, unsigned dy,
unsigned sx, unsigned sy, unsigned w, unsigned h);
void (*surface_copy_done)(struct nouveau_context *);
int (*surface_fill)(struct nouveau_context *, struct pipe_surface *,
unsigned, unsigned, unsigned, unsigned, unsigned);
};
extern int nouveau_context_create(dri_context_t *);
extern void nouveau_context_destroy(dri_context_t *);
extern int nouveau_context_bind(struct nouveau_context *, dri_drawable_t *);
extern int nouveau_context_unbind(struct nouveau_context *);
#ifdef DEBUG
extern int __nouveau_debug;
#define DEBUG_BO (1 << 0)
#define DBG(flag, ...) do { \
if (__nouveau_debug & (DEBUG_##flag)) \
NOUVEAU_ERR(__VA_ARGS__); \
} while(0)
#else
#define DBG(flag, ...)
#endif
extern void LOCK_HARDWARE(struct nouveau_context *);
extern void UNLOCK_HARDWARE(struct nouveau_context *);
extern int
nouveau_surface_channel_create_nv04(struct nouveau_channel_context *);
extern int
nouveau_surface_channel_create_nv50(struct nouveau_channel_context *);
extern int nouveau_surface_init_nv04(struct nouveau_context *);
extern int nouveau_surface_init_nv50(struct nouveau_context *);
extern uint32_t *nouveau_pipe_dma_beginp(struct nouveau_grobj *, int, int);
extern void nouveau_pipe_dma_kickoff(struct nouveau_channel *);
#endif
src/gallium/winsys/g3dvl/nouveau/nouveau_device.c
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_device.c
src/gallium/winsys/g3dvl/nouveau/nouveau_dma.c
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_dma.c
src/gallium/winsys/g3dvl/nouveau/nouveau_dma.h
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_dma.h
src/gallium/winsys/g3dvl/nouveau/nouveau_dri.h
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_dri.h
src/gallium/winsys/g3dvl/nouveau/nouveau_drmif.h
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_drmif.h
src/gallium/winsys/g3dvl/nouveau/nouveau_fence.c
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_fence.c
src/gallium/winsys/g3dvl/nouveau/nouveau_grobj.c
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_grobj.c
src/gallium/winsys/g3dvl/nouveau/nouveau_local.h
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_local.h
src/gallium/winsys/g3dvl/nouveau/nouveau_lock.c
+92
View File
@@ -0,0 +1,92 @@
/**************************************************************************
*
* Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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, sub license, 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 NON-INFRINGEMENT.
* IN NO EVENT SHALL TUNGSTEN GRAPHICS 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.
*
**************************************************************************/
#include <pthread.h>
#include <driclient.h>
#include "nouveau_context.h"
#include "nouveau_screen.h"
static pthread_mutex_t lockMutex = PTHREAD_MUTEX_INITIALIZER;
static void
nouveau_contended_lock(struct nouveau_context *nv, unsigned int flags)
{
dri_drawable_t *dri_drawable = nv->dri_drawable;
dri_screen_t *dri_screen = nv->dri_context->dri_screen;
struct nouveau_screen *nv_screen = nv->nv_screen;
struct nouveau_device *dev = nv_screen->device;
struct nouveau_device_priv *nvdev = nouveau_device(dev);
drmGetLock(nvdev->fd, nvdev->ctx, flags);
/* If the window moved, may need to set a new cliprect now.
*
* NOTE: This releases and regains the hw lock, so all state
* checking must be done *after* this call:
*/
if (dri_drawable)
DRI_VALIDATE_DRAWABLE_INFO(dri_screen, dri_drawable);
}
/* Lock the hardware and validate our state.
*/
void
LOCK_HARDWARE(struct nouveau_context *nv)
{
struct nouveau_screen *nv_screen = nv->nv_screen;
struct nouveau_device *dev = nv_screen->device;
struct nouveau_device_priv *nvdev = nouveau_device(dev);
char __ret=0;
pthread_mutex_lock(&lockMutex);
assert(!nv->locked);
DRM_CAS(nvdev->lock, nvdev->ctx,
(DRM_LOCK_HELD | nvdev->ctx), __ret);
if (__ret)
nouveau_contended_lock(nv, 0);
nv->locked = 1;
}
/* Unlock the hardware using the global current context
*/
void
UNLOCK_HARDWARE(struct nouveau_context *nv)
{
struct nouveau_screen *nv_screen = nv->nv_screen;
struct nouveau_device *dev = nv_screen->device;
struct nouveau_device_priv *nvdev = nouveau_device(dev);
assert(nv->locked);
nv->locked = 0;
DRM_UNLOCK(nvdev->fd, nvdev->lock, nvdev->ctx);
pthread_mutex_unlock(&lockMutex);
}
src/gallium/winsys/g3dvl/nouveau/nouveau_notifier.c
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_notifier.c
src/gallium/winsys/g3dvl/nouveau/nouveau_pushbuf.c
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_pushbuf.c
src/gallium/winsys/g3dvl/nouveau/nouveau_resource.c
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_resource.c
src/gallium/winsys/g3dvl/nouveau/nouveau_screen.c
+88
View File
@@ -0,0 +1,88 @@
#include "pipe/p_context.h"
#include "pipe/p_util.h"
#include "nouveau_context.h"
#include "nouveau_drm.h"
#include "nouveau_dri.h"
#include "nouveau_local.h"
#include "nouveau_screen.h"
#include "nouveau_swapbuffers.h"
#if NOUVEAU_DRM_HEADER_PATCHLEVEL != 11
#error nouveau_drm.h version does not match expected version
#endif
/*
PUBLIC const char __driConfigOptions[] =
DRI_CONF_BEGIN
DRI_CONF_END;
static const GLuint __driNConfigOptions = 0;
*/
int
nouveau_screen_create(dri_screen_t *dri_screen, dri_framebuffer_t *dri_framebuf)
{
/* XXX: Someone forgot to bump this? */
static const dri_version_t ddx_expected = {0, 0, 10 /*NOUVEAU_DRM_HEADER_PATCHLEVEL*/};
static const dri_version_t dri_expected = {4, 1, 0};
static const dri_version_t drm_expected = {0, 0, NOUVEAU_DRM_HEADER_PATCHLEVEL};
struct nouveau_dri *nv_dri = dri_framebuf->private;
struct nouveau_screen *nv_screen;
int ret;
if (!driCompareVersions(&ddx_expected, &dri_screen->ddx))
{
NOUVEAU_ERR("Unexpected DDX version.\n");
return 1;
}
if (!driCompareVersions(&drm_expected, &dri_screen->drm))
{
NOUVEAU_ERR("Unexpected DRM version.\n");
return 1;
}
if (!driCompareVersions(&dri_expected, &dri_screen->dri))
{
NOUVEAU_ERR("Unexpected DRI version.\n");
return 1;
}
if (dri_framebuf->private_size != sizeof(struct nouveau_dri)) {
NOUVEAU_ERR("DRI struct mismatch between DDX/DRI.\n");
return 1;
}
nv_screen = CALLOC_STRUCT(nouveau_screen);
if (!nv_screen)
return 1;
nv_screen->dri_screen = dri_screen;
dri_screen->private = (void*)nv_screen;
/*
driParseOptionInfo(&nv_screen->option_cache,
__driConfigOptions, __driNConfigOptions);
*/
if ((ret = nouveau_device_open_existing(&nv_screen->device, 0,
dri_screen->fd, 0))) {
NOUVEAU_ERR("Failed opening nouveau device: %d.\n", ret);
return 1;
}
nv_screen->front_offset = nv_dri->front_offset;
nv_screen->front_pitch = nv_dri->front_pitch * (nv_dri->bpp / 8);
nv_screen->front_cpp = nv_dri->bpp / 8;
nv_screen->front_height = nv_dri->height;
return 0;
}
void
nouveau_screen_destroy(dri_screen_t *dri_screen)
{
struct nouveau_screen *nv_screen = dri_screen->private;
FREE(nv_screen);
}
src/gallium/winsys/g3dvl/nouveau/nouveau_screen.h
+24
View File
@@ -0,0 +1,24 @@
#ifndef __NOUVEAU_SCREEN_H__
#define __NOUVEAU_SCREEN_H__
/* TODO: Investigate using DRI options for interesting things */
/*#include "xmlconfig.h"*/
struct nouveau_screen {
dri_screen_t *dri_screen;
struct nouveau_device *device;
struct nouveau_channel_context *nvc;
uint32_t front_offset;
uint32_t front_pitch;
uint32_t front_cpp;
uint32_t front_height;
/*driOptionCache option_cache;*/
};
int nouveau_screen_create(dri_screen_t *dri_screen, dri_framebuffer_t *dri_framebuf);
void nouveau_screen_destroy(dri_screen_t *dri_screen);
#endif
src/gallium/winsys/g3dvl/nouveau/nouveau_swapbuffers.c
+64
View File
@@ -0,0 +1,64 @@
#include "pipe/p_context.h"
#include "nouveau_context.h"
#include "nouveau_local.h"
#include "nouveau_screen.h"
#include "nouveau_swapbuffers.h"
void
nouveau_copy_buffer(dri_drawable_t *dri_drawable, struct pipe_surface *surf,
const drm_clip_rect_t *rect)
{
struct nouveau_context *nv = dri_drawable->private;
drm_clip_rect_t *pbox;
int nbox, i;
LOCK_HARDWARE(nv);
if (!dri_drawable->num_cliprects) {
UNLOCK_HARDWARE(nv);
return;
}
pbox = dri_drawable->cliprects;
nbox = dri_drawable->num_cliprects;
nv->surface_copy_prep(nv, nv->frontbuffer, surf);
for (i = 0; i < nbox; i++, pbox++) {
int sx, sy, dx, dy, w, h;
sx = pbox->x1 - dri_drawable->x;
sy = pbox->y1 - dri_drawable->y;
dx = pbox->x1;
dy = pbox->y1;
w = pbox->x2 - pbox->x1;
h = pbox->y2 - pbox->y1;
nv->surface_copy(nv, dx, dy, sx, sy, w, h);
}
FIRE_RING(nv->nvc->channel);
UNLOCK_HARDWARE(nv);
//if (nv->last_stamp != dri_drawable->last_sarea_stamp)
//nv->last_stamp = dri_drawable->last_sarea_stamp;
}
void
nouveau_copy_sub_buffer(dri_drawable_t *dri_drawable, struct pipe_surface *surf, int x, int y, int w, int h)
{
if (surf) {
drm_clip_rect_t rect;
rect.x1 = x;
rect.y1 = y;
rect.x2 = x + w;
rect.y2 = y + h;
nouveau_copy_buffer(dri_drawable, surf, &rect);
}
}
void
nouveau_swap_buffers(dri_drawable_t *dri_drawable, struct pipe_surface *surf)
{
if (surf)
nouveau_copy_buffer(dri_drawable, surf, NULL);
}
src/gallium/winsys/g3dvl/nouveau/nouveau_swapbuffers.h
+10
View File
@@ -0,0 +1,10 @@
#ifndef __NOUVEAU_SWAPBUFFERS_H__
#define __NOUVEAU_SWAPBUFFERS_H__
extern void nouveau_copy_buffer(dri_drawable_t *, struct pipe_surface *,
const drm_clip_rect_t *);
extern void nouveau_copy_sub_buffer(dri_drawable_t *, struct pipe_surface *,
int x, int y, int w, int h);
extern void nouveau_swap_buffers(dri_drawable_t *, struct pipe_surface *);
#endif
src/gallium/winsys/g3dvl/nouveau/nouveau_winsys.c
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_winsys.c
src/gallium/winsys/g3dvl/nouveau/nouveau_winsys_pipe.c
+261
View File
@@ -0,0 +1,261 @@
#include "pipe/p_winsys.h"
#include "pipe/p_defines.h"
#include "pipe/p_util.h"
#include "pipe/p_inlines.h"
#include "nouveau_context.h"
#include "nouveau_local.h"
#include "nouveau_screen.h"
#include "nouveau_swapbuffers.h"
#include "nouveau_winsys_pipe.h"
static void
nouveau_flush_frontbuffer(struct pipe_winsys *pws, struct pipe_surface *surf,
void *context_private)
{
struct nouveau_context *nv = context_private;
dri_drawable_t *dri_drawable = nv->dri_drawable;
nouveau_copy_buffer(dri_drawable, surf, NULL);
}
static const char *
nouveau_get_name(struct pipe_winsys *pws)
{
return "Nouveau/DRI";
}
static struct pipe_surface *
nouveau_surface_alloc(struct pipe_winsys *ws)
{
struct pipe_surface *surf;
surf = CALLOC_STRUCT(pipe_surface);
if (!surf)
return NULL;
surf->refcount = 1;
surf->winsys = ws;
return surf;
}
/* Borrowed from Mesa's xm_winsys */
static unsigned int
round_up(unsigned n, unsigned multiple)
{
return (n + multiple - 1) & ~(multiple - 1);
}
static int
nouveau_surface_alloc_storage
(
struct pipe_winsys *pws,
struct pipe_surface *surface,
unsigned width,
unsigned height,
enum pipe_format format,
unsigned flags,
unsigned tex_usage
)
{
const unsigned int ALIGNMENT = 256;
assert(pws);
assert(surface);
surface->width = width;
surface->height = height;
surface->format = format;
pf_get_block(format, &surface->block);
surface->nblocksx = pf_get_nblocksx(&surface->block, width);
surface->nblocksy = pf_get_nblocksy(&surface->block, height);
surface->stride = round_up(surface->nblocksx * surface->block.size, ALIGNMENT);
surface->usage = flags;
surface->buffer = pws->buffer_create(pws, ALIGNMENT, PIPE_BUFFER_USAGE_PIXEL, surface->stride * surface->nblocksy);
return 0;
}
static void
nouveau_surface_release(struct pipe_winsys *ws, struct pipe_surface **s)
{
struct pipe_surface *surf = *s;
*s = NULL;
if (--surf->refcount <= 0) {
if (surf->buffer)
pipe_buffer_reference(ws, &surf->buffer, NULL);
free(surf);
}
}
static struct pipe_buffer *
nouveau_pipe_bo_create(struct pipe_winsys *pws, unsigned alignment,
unsigned usage, unsigned size)
{
struct nouveau_pipe_winsys *nvpws = (struct nouveau_pipe_winsys *)pws;
struct nouveau_context *nv = nvpws->nv;
struct nouveau_device *dev = nv->nv_screen->device;
struct nouveau_pipe_buffer *nvbuf;
uint32_t flags;
nvbuf = calloc(1, sizeof(*nvbuf));
if (!nvbuf)
return NULL;
nvbuf->base.refcount = 1;
nvbuf->base.alignment = alignment;
nvbuf->base.usage = usage;
nvbuf->base.size = size;
flags = NOUVEAU_BO_LOCAL;
if (usage & PIPE_BUFFER_USAGE_PIXEL) {
if (usage & NOUVEAU_BUFFER_USAGE_TEXTURE)
flags |= NOUVEAU_BO_GART;
flags |= NOUVEAU_BO_VRAM;
}
if (usage & PIPE_BUFFER_USAGE_VERTEX) {
if (nv->cap.hw_vertex_buffer)
flags |= NOUVEAU_BO_GART;
}
if (usage & PIPE_BUFFER_USAGE_INDEX) {
if (nv->cap.hw_index_buffer)
flags |= NOUVEAU_BO_GART;
}
if (nouveau_bo_new(dev, flags, alignment, size, &nvbuf->bo)) {
free(nvbuf);
return NULL;
}
return &nvbuf->base;
}
static struct pipe_buffer *
nouveau_pipe_bo_user_create(struct pipe_winsys *pws, void *ptr, unsigned bytes)
{
struct nouveau_pipe_winsys *nvpws = (struct nouveau_pipe_winsys *)pws;
struct nouveau_device *dev = nvpws->nv->nv_screen->device;
struct nouveau_pipe_buffer *nvbuf;
nvbuf = calloc(1, sizeof(*nvbuf));
if (!nvbuf)
return NULL;
nvbuf->base.refcount = 1;
nvbuf->base.size = bytes;
if (nouveau_bo_user(dev, ptr, bytes, &nvbuf->bo)) {
free(nvbuf);
return NULL;
}
return &nvbuf->base;
}
static void
nouveau_pipe_bo_del(struct pipe_winsys *ws, struct pipe_buffer *buf)
{
struct nouveau_pipe_buffer *nvbuf = nouveau_buffer(buf);
nouveau_bo_del(&nvbuf->bo);
free(nvbuf);
}
static void *
nouveau_pipe_bo_map(struct pipe_winsys *pws, struct pipe_buffer *buf,
unsigned flags)
{
struct nouveau_pipe_buffer *nvbuf = nouveau_buffer(buf);
uint32_t map_flags = 0;
if (flags & PIPE_BUFFER_USAGE_CPU_READ)
map_flags |= NOUVEAU_BO_RD;
if (flags & PIPE_BUFFER_USAGE_CPU_WRITE)
map_flags |= NOUVEAU_BO_WR;
if (nouveau_bo_map(nvbuf->bo, map_flags))
return NULL;
return nvbuf->bo->map;
}
static void
nouveau_pipe_bo_unmap(struct pipe_winsys *pws, struct pipe_buffer *buf)
{
struct nouveau_pipe_buffer *nvbuf = nouveau_buffer(buf);
nouveau_bo_unmap(nvbuf->bo);
}
static INLINE struct nouveau_fence *
nouveau_pipe_fence(struct pipe_fence_handle *pfence)
{
return (struct nouveau_fence *)pfence;
}
static void
nouveau_pipe_fence_reference(struct pipe_winsys *ws,
struct pipe_fence_handle **ptr,
struct pipe_fence_handle *pfence)
{
nouveau_fence_ref((void *)pfence, (void *)ptr);
}
static int
nouveau_pipe_fence_signalled(struct pipe_winsys *ws,
struct pipe_fence_handle *pfence, unsigned flag)
{
struct nouveau_pipe_winsys *nvpws = (struct nouveau_pipe_winsys *)ws;
struct nouveau_fence *fence = nouveau_pipe_fence(pfence);
if (nouveau_fence(fence)->signalled == 0)
nouveau_fence_flush(nvpws->nv->nvc->channel);
return !nouveau_fence(fence)->signalled;
}
static int
nouveau_pipe_fence_finish(struct pipe_winsys *ws,
struct pipe_fence_handle *pfence, unsigned flag)
{
struct nouveau_fence *fence = nouveau_pipe_fence(pfence);
struct nouveau_fence *ref = NULL;
nouveau_fence_ref(fence, &ref);
return nouveau_fence_wait(&ref);
}
struct pipe_winsys *
nouveau_create_pipe_winsys(struct nouveau_context *nv)
{
struct nouveau_pipe_winsys *nvpws;
struct pipe_winsys *pws;
nvpws = CALLOC_STRUCT(nouveau_pipe_winsys);
if (!nvpws)
return NULL;
nvpws->nv = nv;
pws = &nvpws->pws;
pws->flush_frontbuffer = nouveau_flush_frontbuffer;
pws->surface_alloc = nouveau_surface_alloc;
pws->surface_alloc_storage = nouveau_surface_alloc_storage;
pws->surface_release = nouveau_surface_release;
pws->buffer_create = nouveau_pipe_bo_create;
pws->buffer_destroy = nouveau_pipe_bo_del;
pws->user_buffer_create = nouveau_pipe_bo_user_create;
pws->buffer_map = nouveau_pipe_bo_map;
pws->buffer_unmap = nouveau_pipe_bo_unmap;
pws->fence_reference = nouveau_pipe_fence_reference;
pws->fence_signalled = nouveau_pipe_fence_signalled;
pws->fence_finish = nouveau_pipe_fence_finish;
pws->get_name = nouveau_get_name;
return &nvpws->pws;
}
src/gallium/winsys/g3dvl/nouveau/nouveau_winsys_pipe.h
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_winsys_pipe.h
src/gallium/winsys/g3dvl/nouveau/nouveau_winsys_softpipe.c
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nouveau_winsys_softpipe.c
src/gallium/winsys/g3dvl/nouveau/nv04_surface.c
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nv04_surface.c
src/gallium/winsys/g3dvl/nouveau/nv50_surface.c
Symlink
+1
View File
@@ -0,0 +1 @@
../../dri/nouveau/nv50_surface.c
src/gallium/winsys/g3dvl/vl_winsys.h
+14
View File
@@ -0,0 +1,14 @@
#ifndef vl_winsys_h
#define vl_winsys_h
#include <X11/Xlib.h>
struct pipe_context;
struct pipe_context* create_pipe_context(Display *display, int screen);
int destroy_pipe_context(struct pipe_context *pipe);
int bind_pipe_drawable(struct pipe_context *pipe, Drawable drawable);
int unbind_pipe_drawable(struct pipe_context *pipe);
#endif
src/gallium/winsys/g3dvl/xsp_winsys.c
+58 -14
View File
@@ -1,4 +1,4 @@
#include "xsp_winsys.h"
#include "vl_winsys.h"
#include <X11/Xutil.h>
#include <pipe/p_winsys.h>
#include <pipe/p_state.h>
@@ -11,10 +11,17 @@
struct xsp_pipe_winsys
{
struct pipe_winsys base;
Display *display;
XImage fbimage;
};
struct xsp_context
{
Display *display;
int screen;
Drawable drawable;
int drawable_bound;
};
struct xsp_buffer
{
struct pipe_buffer base;
@@ -183,13 +190,18 @@ static int xsp_fence_finish(struct pipe_winsys *pws, struct pipe_fence_handle *f
static void xsp_flush_frontbuffer(struct pipe_winsys *pws, struct pipe_surface *surface, void *context_private)
{
struct xsp_pipe_winsys *xsp_winsys;
struct xsp_pipe_winsys *xsp_winsys;
struct xsp_context *xsp_context;
assert(pws);
assert(surface);
assert(context_private);
xsp_winsys = (struct xsp_pipe_winsys*)pws;
xsp_context = (struct xsp_context*)context_private;
if (!xsp_context->drawable_bound)
return;
xsp_winsys->fbimage.width = surface->width;
xsp_winsys->fbimage.height = surface->height;
@@ -198,9 +210,9 @@ static void xsp_flush_frontbuffer(struct pipe_winsys *pws, struct pipe_surface *
XPutImage
(
xsp_winsys->display,
*(Drawable*)context_private,
XDefaultGC(xsp_winsys->display, XDefaultScreen(xsp_winsys->display)),
xsp_context->display,
xsp_context->drawable,
XDefaultGC(xsp_context->display, xsp_context->screen),
&xsp_winsys->fbimage,
0,
0,
@@ -209,7 +221,7 @@ static void xsp_flush_frontbuffer(struct pipe_winsys *pws, struct pipe_surface *
surface->width,
surface->height
);
XFlush(xsp_winsys->display);
XFlush(xsp_context->display);
pipe_surface_unmap(surface);
}
@@ -221,11 +233,37 @@ static const char* xsp_get_name(struct pipe_winsys *pws)
/* Show starts here */
struct pipe_context* create_pipe_context(Display *display)
int bind_pipe_drawable(struct pipe_context *pipe, Drawable drawable)
{
struct xsp_context *xsp_context;
assert(pipe);
xsp_context = pipe->priv;
xsp_context->drawable = drawable;
xsp_context->drawable_bound = 1;
return 0;
}
int unbind_pipe_drawable(struct pipe_context *pipe)
{
struct xsp_context *xsp_context;
assert(pipe);
xsp_context = pipe->priv;
xsp_context->drawable_bound = 0;
return 0;
}
struct pipe_context* create_pipe_context(Display *display, int screen)
{
struct xsp_pipe_winsys *xsp_winsys;
struct pipe_screen *screen;
struct pipe_context *pipe;
struct xsp_context *xsp_context;
struct pipe_screen *sp_screen;
struct pipe_context *sp_pipe;
assert(display);
@@ -243,7 +281,6 @@ struct pipe_context* create_pipe_context(Display *display)
xsp_winsys->base.fence_finish = xsp_fence_finish;
xsp_winsys->base.flush_frontbuffer = xsp_flush_frontbuffer;
xsp_winsys->base.get_name = xsp_get_name;
xsp_winsys->display = display;
{
/* XXX: Can't use the returned XImage* directly,
@@ -269,10 +306,16 @@ struct pipe_context* create_pipe_context(Display *display)
XDestroyImage(template);
}
screen = softpipe_create_screen((struct pipe_winsys*)xsp_winsys);
pipe = softpipe_create(screen, (struct pipe_winsys*)xsp_winsys, NULL);
sp_screen = softpipe_create_screen((struct pipe_winsys*)xsp_winsys);
sp_pipe = softpipe_create(sp_screen, (struct pipe_winsys*)xsp_winsys, NULL);
return pipe;
xsp_context = calloc(1, sizeof(struct xsp_context));
xsp_context->display = display;
xsp_context->screen = screen;
sp_pipe->priv = xsp_context;
return sp_pipe;
}
int destroy_pipe_context(struct pipe_context *pipe)
@@ -284,6 +327,7 @@ int destroy_pipe_context(struct pipe_context *pipe)
screen = pipe->screen;
winsys = pipe->winsys;
free(pipe->priv);
pipe->destroy(pipe);
screen->destroy(screen);
free(winsys);
src/gallium/winsys/g3dvl/xsp_winsys.h
-12
View File
@@ -1,12 +0,0 @@
#ifndef xsp_winsys_h
#define xsp_winsys_h
#include <X11/Xlib.h>
struct pipe_context;
struct pipe_context* create_pipe_context(Display *display);
int destroy_pipe_context(struct pipe_context *pipe);
#endif
src/libXvMC/Makefile
+18 -1
View File
@@ -1,7 +1,12 @@
TARGET = libXvMCg3dvl.so
SONAME = libXvMCg3dvl.so.1
GALLIUMDIR = ../gallium
OBJECTS = block.o surface.o context.o subpicture.o attributes.o ${GALLIUMDIR}/winsys/g3dvl/xsp_winsys.o
OBJECTS = block.o surface.o context.o subpicture.o attributes.o
ifeq (${DRIVER}, softpipe)
OBJECTS += ${GALLIUMDIR}/winsys/g3dvl/xsp_winsys.o
endif
CFLAGS += -g -fPIC -Wall -Werror \
-I${GALLIUMDIR}/state_trackers/g3dvl \
@@ -9,6 +14,8 @@ CFLAGS += -g -fPIC -Wall -Werror \
-I${GALLIUMDIR}/include \
-I${GALLIUMDIR}/auxiliary \
-I${GALLIUMDIR}/drivers
ifeq (${DRIVER}, softpipe)
LDFLAGS += -L${GALLIUMDIR}/state_trackers/g3dvl \
-L${GALLIUMDIR}/drivers/softpipe \
-L${GALLIUMDIR}/auxiliary/tgsi \
@@ -17,7 +24,17 @@ LDFLAGS += -L${GALLIUMDIR}/state_trackers/g3dvl \
-L${GALLIUMDIR}/auxiliary/cso_cache \
-L${GALLIUMDIR}/auxiliary/util \
-L${GALLIUMDIR}/auxiliary/rtasm
else
LDFLAGS += -L${GALLIUMDIR}/state_trackers/g3dvl \
-L${GALLIUMDIR}/winsys/g3dvl/nouveau \
-L${GALLIUMDIR}/auxiliary/util
endif
ifeq (${DRIVER}, softpipe)
LIBS += -lg3dvl -lsoftpipe -ldraw -ltgsi -ltranslate -lrtasm -lcso_cache -lutil -lm
else
LIBS += -lg3dvl -lnouveau_dri -lutil
endif
#############################################
src/libXvMC/context.c
+2 -2
View File
@@ -2,7 +2,7 @@
#include <X11/Xlib.h>
#include <X11/extensions/XvMClib.h>
#include <vl_context.h>
#include <xsp_winsys.h>
#include <vl_winsys.h>
static Status Validate(Display *display, XvPortID port, int surface_type_id, unsigned int width, unsigned int height, int flags, int *chroma_format)
{
@@ -117,7 +117,7 @@ Status XvMCCreateContext(Display *display, XvPortID port, int surface_type_id, i
if (ret != Success)
return ret;
pipe = create_pipe_context(display);
pipe = create_pipe_context(display, XDefaultScreen(display));
assert(pipe);