fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-23 09:00:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Update DRI drivers to current DRI CVS and make them work.

Browse source
This commit is contained in:
Jon Smirl 2003-10-21 06:05:39 +00:00
parent 906449753f
commit bcc6eddd33
96 changed files with 3627 additions and 1302 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Make-config
View file

@ -721,7 +721,7 @@ linux-solo:
"CFLAGS = -g -std=c99 -pedantic -fPIC -ffast-math -D_POSIX_SOURCE -D_POSIX_C_SOURCE=199309L -D_SVID_SOURCE -D_BSD_SOURCE" \
"CXXFLAGS = -g -std=c99 -pedantic -fPIC -ffast-math -D_POSIX_SOURCE -D_POSIX_C_SOURCE=199309L -D_SVID_SOURCE -D_BSD_SOURCE" \
"GLUT_CFLAGS = -fexceptions" \
"GL_LIB_DEPS = -lm -lpthread" \
"GL_LIB_DEPS = -lm -lpthread -lexpat" \
"GLU_LIB_DEPS = -L$(TOP)/lib -lGL -lm -Wl,-rpath,$(TOP)/lib" \
"GLUT_LIB_DEPS = -L$(TOP)/lib -lGLU -lGL -lm -Wl,-rpath,$(TOP)/lib" \
"APP_LIB_DEPS = -L$(TOP)/lib -lglut -lGLU -lGL -lm -lpthread -Wl,-rpath,$(TOP)/lib"

6
src/glx/mini/dri_util.h
View file

@ -488,6 +488,12 @@ struct __DRIscreenPrivateRec {
* the drawable that was bound. Otherwise, this is NULL.
*/
__DRIdrawablePrivate *fullscreen;
/**
* \brief Screen number for when multiple screens are supported
*/
int myNum;
};
extern void

4
src/glx/mini/miniglx.c
View file

@ -31,7 +31,7 @@
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/* $Id: miniglx.c,v 1.1 2003/08/22 20:11:43 brianp Exp $ */
/* $Id: miniglx.c,v 1.2 2003/10/21 06:05:40 jonsmirl Exp $ */
/**
* \mainpage Mini GLX
@ -732,7 +732,7 @@ static int get_chipset_from_busid( Display *dpy )
nr = sscanf(buf, "%04x\t%04x%04x", &encode,
&vendor, &device);
bus = encode >> 16;
bus = encode >> 8;
dev = (encode & 0xFF) >> 3;
fn = encode & 0x7;

3
src/mesa/drivers/dri/common/mm.c
View file

@ -27,14 +27,13 @@
#include <stdio.h>
#include "mm.h"
#include "hwlog.h"
void mmDumpMemInfo( memHeap_t *heap )
{
TMemBlock *p;
fprintf(stderr, "Memory heap %p:\n", heap);
fprintf(stderr, "Memory heap %p:\n", (void *)heap);
if (heap == 0) {
fprintf(stderr, " heap == 0\n");
} else {

96
src/mesa/drivers/dri/common/texmem.c
View file

@ -1,6 +1,6 @@
/*
* Copyright 2000-2001 VA Linux Systems, Inc.
* (c) Copyright IBM Corporation 2002
* (C) Copyright IBM Corporation 2002, 2003
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
@ -46,6 +46,7 @@
#include "texmem.h"
#include "simple_list.h"
#include "imports.h"
#include "macros.h"
#include <assert.h>
@ -156,22 +157,22 @@ static void printLocalLRU( driTexHeap * heap, const char *callername )
continue;
if (!t->tObj) {
fprintf( stderr, "Placeholder (%p) %d at 0x%x sz 0x%x\n",
t,
(void *)t,
t->memBlock->ofs / sz,
t->memBlock->ofs,
t->memBlock->size );
} else {
fprintf( stderr, "Texture (%p) at 0x%x sz 0x%x\n",
t,
(void *)t,
t->memBlock->ofs,
t->memBlock->size );
}
}
foreach ( t, heap->swapped_objects ) {
if (!t->tObj) {
fprintf( stderr, "Swapped Placeholder (%p)\n", t );
fprintf( stderr, "Swapped Placeholder (%p)\n", (void *)t );
} else {
fprintf( stderr, "Swapped Texture (%p)\n", t );
fprintf( stderr, "Swapped Texture (%p)\n", (void *)t );
}
}
@ -190,7 +191,7 @@ static void printGlobalLRU( driTexHeap * heap, const char *callername )
int i, j;
fprintf( stderr, "%s in %s:\nGlobal LRU, heap %d list %p:\n",
__FUNCTION__, callername, heap->heapId, list );
__FUNCTION__, callername, heap->heapId, (void *)list );
for ( i = 0, j = heap->nrRegions ; i < heap->nrRegions ; i++ ) {
fprintf( stderr, "list[%d] age %d next %d prev %d in_use %d\n",
@ -323,9 +324,9 @@ void driDestroyTextureObject( driTextureObject * t )
if ( 0 ) {
fprintf( stderr, "[%s:%d] freeing %p (tObj = %p, DriverData = %p)\n",
__FILE__, __LINE__,
t,
(t != NULL) ? t->tObj : NULL,
(t != NULL && t->tObj != NULL) ? t->tObj->DriverData : NULL );
(void *)t,
(void *)((t != NULL) ? t->tObj : NULL),
(void *)((t != NULL && t->tObj != NULL) ? t->tObj->DriverData : NULL ));
}
if ( t != NULL ) {
@ -355,7 +356,7 @@ void driDestroyTextureObject( driTextureObject * t )
}
if ( 0 ) {
fprintf( stderr, "[%s:%d] done freeing %p\n", __FILE__, __LINE__, t );
fprintf( stderr, "[%s:%d] done freeing %p\n", __FILE__, __LINE__, (void *)t );
}
}
@ -645,7 +646,7 @@ driCreateTextureHeap( unsigned heap_id, void * context, unsigned size,
if ( 0 )
fprintf( stderr, "%s( %u, %p, %u, %u, %u )\n",
__FUNCTION__,
heap_id, context, size, alignmentShift, nr_regions );
heap_id, (void *)context, size, alignmentShift, nr_regions );
heap = (driTexHeap *) CALLOC( sizeof( driTexHeap ) );
if ( heap != NULL ) {
@ -688,7 +689,7 @@ driCreateTextureHeap( unsigned heap_id, void * context, unsigned size,
if ( 0 )
fprintf( stderr, "%s returning %p\n", __FUNCTION__, heap );
fprintf( stderr, "%s returning %p\n", __FUNCTION__, (void *)heap );
return heap;
}
@ -894,7 +895,7 @@ get_max_size( unsigned nr_heaps,
/**
* Given the amount of texture memory, the number of texture units, and the
* maximum size of a texel, calculate the maximum texture size the driver can
* adverteise.
* advertise.
*
* \param heaps Texture heaps for this card
* \param nr_heap Number of texture heaps
@ -1097,7 +1098,7 @@ driValidateTextureHeaps( driTexHeap * const * texture_heaps,
if ( !check_in_heap( t, heap ) ) {
fprintf( stderr, "%s memory block for texture object @ %p not "
"found in heap #%d\n",
__FUNCTION__, t, i );
__FUNCTION__, (void *)t, i );
return GL_FALSE;
}
@ -1105,7 +1106,7 @@ driValidateTextureHeaps( driTexHeap * const * texture_heaps,
if ( t->totalSize > t->memBlock->size ) {
fprintf( stderr, "%s: Memory block for texture object @ %p is "
"only %u bytes, but %u are required\n",
__FUNCTION__, t, t->totalSize, t->memBlock->size );
__FUNCTION__, (void *)t, t->totalSize, t->memBlock->size );
return GL_FALSE;
}
@ -1159,15 +1160,76 @@ driValidateTextureHeaps( driTexHeap * const * texture_heaps,
foreach ( t, swapped ) {
if ( t->memBlock != NULL ) {
fprintf( stderr, "%s: Swapped texobj %p has non-NULL memblock %p\n",
__FUNCTION__, t, t->memBlock );
__FUNCTION__, (void *)t, (void *)t->memBlock );
return GL_FALSE;
}
i++;
}
#if 0
fprintf( stderr, "%s: swapped texture count = %u\n", i );
fprintf( stderr, "%s: swapped texture count = %u\n", __FUNCTION__, i );
#endif
return GL_TRUE;
}
/****************************************************************************/
/**
* Compute which mipmap levels that really need to be sent to the hardware.
* This depends on the base image size, GL_TEXTURE_MIN_LOD,
* GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL.
*/
void
driCalculateTextureFirstLastLevel( driTextureObject * t )
{
struct gl_texture_object * const tObj = t->tObj;
const struct gl_texture_image * const baseImage =
tObj->Image[tObj->BaseLevel];
/* These must be signed values. MinLod and MaxLod can be negative numbers,
* and having firstLevel and lastLevel as signed prevents the need for
* extra sign checks.
*/
int firstLevel;
int lastLevel;
/* Yes, this looks overly complicated, but it's all needed.
*/
switch (tObj->Target) {
case GL_TEXTURE_1D:
case GL_TEXTURE_2D:
case GL_TEXTURE_3D:
case GL_TEXTURE_CUBE_MAP:
if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) {
/* GL_NEAREST and GL_LINEAR only care about GL_TEXTURE_BASE_LEVEL.
*/
firstLevel = lastLevel = tObj->BaseLevel;
}
else {
firstLevel = tObj->BaseLevel + (GLint)(tObj->MinLod + 0.5);
firstLevel = MAX2(firstLevel, tObj->BaseLevel);
lastLevel = tObj->BaseLevel + (GLint)(tObj->MaxLod + 0.5);
lastLevel = MAX2(lastLevel, t->tObj->BaseLevel);
lastLevel = MIN2(lastLevel, t->tObj->BaseLevel + baseImage->MaxLog2);
lastLevel = MIN2(lastLevel, t->tObj->MaxLevel);
lastLevel = MAX2(firstLevel, lastLevel); /* need at least one level */
}
break;
case GL_TEXTURE_RECTANGLE_NV:
case GL_TEXTURE_4D_SGIS:
firstLevel = lastLevel = 0;
break;
default:
return;
}
/* save these values */
t->firstLevel = firstLevel;
t->lastLevel = lastLevel;
}

2
src/mesa/drivers/dri/common/texmem.h
View file

@ -290,4 +290,6 @@ void driInitTextureObjects( GLcontext *ctx, driTextureObject * swapped,
GLboolean driValidateTextureHeaps( driTexHeap * const * texture_heaps,
unsigned nr_heaps, const driTextureObject * swapped );
extern void driCalculateTextureFirstLastLevel( driTextureObject * t );
#endif /* DRI_TEXMEM_H */

54
src/mesa/drivers/dri/common/vblank.c
View file

@ -33,6 +33,7 @@
#include "macros.h"
#include "dd.h"
#include "vblank.h"
#include "xmlpool.h"
/****************************************************************************/
@ -183,25 +184,56 @@ int driWaitForMSC32( __DRIdrawablePrivate *priv,
/****************************************************************************/
/**
* Gets a set of default vertical-blank-wait flags based on the internal GLX
* API version and several environment variables.
* API version and several configuration options.
*/
GLuint driGetDefaultVBlankFlags( void )
GLuint driGetDefaultVBlankFlags( const driOptionCache *optionCache )
{
GLuint flags = 0;
int vblank_mode;
flags |= (driCompareGLXAPIVersion( 20030317 ) >= 0)
? VBLANK_FLAG_INTERVAL : 0;
flags |= (getenv("LIBGL_SYNC_REFRESH") != NULL)
? VBLANK_FLAG_SYNC : 0;
flags |= (getenv("LIBGL_THROTTLE_REFRESH") != NULL)
? VBLANK_FLAG_THROTTLE : 0;
if ( driCheckOption( optionCache, "vblank_mode", DRI_ENUM ) )
vblank_mode = driQueryOptioni( optionCache, "vblank_mode" );
else
vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1;
switch (vblank_mode) {
case DRI_CONF_VBLANK_NEVER:
flags = 0;
break;
case DRI_CONF_VBLANK_DEF_INTERVAL_0:
break;
case DRI_CONF_VBLANK_DEF_INTERVAL_1:
flags |= VBLANK_FLAG_THROTTLE;
break;
case DRI_CONF_VBLANK_ALWAYS_SYNC:
flags |= VBLANK_FLAG_SYNC;
break;
}
return flags;
}
/****************************************************************************/
/**
* Sets the default swap interval when the drawable is first bound to a
* direct rendering context.
*/
void driDrawableInitVBlank( __DRIdrawablePrivate *priv, GLuint flags )
{
#ifndef _SOLO
if ( priv->pdraw->swap_interval == (unsigned)-1 ) {
priv->pdraw->swap_interval = (flags & VBLANK_FLAG_THROTTLE) != 0 ? 1 : 0;
}
#endif
}
/****************************************************************************/
/**
* Wrapper to call \c drmWaitVBlank. The main purpose of this function is to
@ -265,7 +297,10 @@ driWaitForVBlank( const __DRIdrawablePrivate *priv, GLuint * vbl_seq,
*missed_deadline = GL_FALSE;
if ( (flags & VBLANK_FLAG_NO_IRQ) != 0 ) {
if ( (flags & (VBLANK_FLAG_INTERVAL |
VBLANK_FLAG_THROTTLE |
VBLANK_FLAG_SYNC)) == 0 ||
(flags & VBLANK_FLAG_NO_IRQ) != 0 ) {
return 0;
}
@ -298,6 +333,9 @@ driWaitForVBlank( const __DRIdrawablePrivate *priv, GLuint * vbl_seq,
#else
interval = 0;
#endif
/* this must have been initialized when the drawable was first bound
* to a direct rendering context. */
assert ( interval != (unsigned)-1 );
}
else if ( (flags & VBLANK_FLAG_THROTTLE) != 0 ) {
interval = 1;

4
src/mesa/drivers/dri/common/vblank.h
View file

@ -32,6 +32,7 @@
#include "context.h"
#include "dri_util.h"
#include "xmlconfig.h"
#define VBLANK_FLAG_INTERVAL (1U << 0) /* Respect the swap_interval setting
*/
@ -45,7 +46,8 @@
extern int driGetMSC32( __DRIscreenPrivate * priv, int64_t * count );
extern int driWaitForMSC32( __DRIdrawablePrivate *priv,
int64_t target_msc, int64_t divisor, int64_t remainder, int64_t * msc );
extern GLuint driGetDefaultVBlankFlags( void );
extern GLuint driGetDefaultVBlankFlags( const driOptionCache *optionCache );
extern void driDrawableInitVBlank ( __DRIdrawablePrivate *priv, GLuint flags );
extern int driWaitForVBlank( const __DRIdrawablePrivate *priv,
GLuint * vbl_seq, GLuint flags, GLboolean * missed_deadline );

862
src/mesa/drivers/dri/common/xmlconfig.c Normal file
View file

@ -0,0 +1,862 @@
/*
* XML DRI client-side driver configuration
* Copyright (C) 2003 Felix Kuehling
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* FELIX KUEHLING, OR ANY OTHER CONTRIBUTORS 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 xmlconfig.c
* \brief Driver-independent client-side part of the XML configuration
* \author Felix Kuehling
*/
#include "glheader.h"
#include <string.h>
#include <assert.h>
#include <expat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include "imports.h"
#include "dri_util.h"
#include "xmlconfig.h"
/*
* OS dependent ways of getting the name of the running program
*/
#if (defined(__unix__) || defined(unix)) && !defined(USG)
#include <sys/param.h>
#endif
#undef GET_PROGRAM_NAME
#if defined(__GNU_LIBRARY__) || defined(__GLIBC__)
# define GET_PROGRAM_NAME() program_invocation_short_name
#elif defined(__FreeBSD__) && (__FreeBSD__ >= 2)
# include <osreldate.h>
# if (__FreeBSD_version >= 440000)
# include <stdlib.h>
# define GET_PROGRAM_NAME() getprogname()
# endif
#elif defined(__NetBSD__) && defined(__NetBSD_Version) && (__NetBSD_Version >= 106000100)
# include <stdlib.h>
# define GET_PROGRAM_NAME() getprogname()
#endif
#if !defined(GET_PROGRAM_NAME)
# if defined(OpenBSD) || defined(NetBSD)
/* This is a hack. It's said to work on OpenBSD, NetBSD and GNU. It's
* used as a last resort, if there is no documented facility available. */
static const char *__getProgramName () {
extern const char *__progname;
return progname;
}
# define GET_PROGRAM_NAME() __getProgramName()
# else
# define GET_PROGRAM_NAME() ""
# warning "Per application configuration won't with your OS version work."
# endif
#endif
/** \brief Find an option in an option cache with the name as key */
static GLuint findOption (const driOptionCache *cache, const char *name) {
GLuint len = strlen (name);
GLuint size = 1 << cache->tableSize, mask = size - 1;
GLuint hash = 0;
GLuint i, shift;
/* compute a hash from the variable length name */
for (i = 0, shift = 0; i < len; ++i, shift = (shift+8) & 31)
hash += (GLuint)name[i] << shift;
hash *= hash;
hash = (hash >> (16-cache->tableSize/2)) & mask;
/* this is just the starting point of the linear search for the option */
for (i = 0; i < size; ++i, hash = (hash+1) & mask) {
/* if we hit an empty entry then the option is not defined (yet) */
if (cache->info[hash].name == 0)
break;
else if (!strcmp (name, cache->info[hash].name))
break;
}
/* this assertion fails if the hash table is full */
assert (i < size);
return hash;
}
/** \brief Count the real number of options in an option cache */
static GLuint countOptions (const driOptionCache *cache) {
GLuint size = 1 << cache->tableSize;
GLuint i, count = 0;
for (i = 0; i < size; ++i)
if (cache->info[i].name)
count++;
return count;
}
/** \brief Like strdup but using MALLOC and with error checking. */
#define XSTRDUP(dest,source) do { \
GLuint len = strlen (source); \
if (!(dest = MALLOC (len+1))) { \
fprintf (stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__); \
abort(); \
} \
memcpy (dest, source, len+1); \
} while (0)
static int compare (const void *a, const void *b) {
return strcmp (*(char *const*)a, *(char *const*)b);
}
/** \brief Binary search in a string array. */
static GLuint bsearchStr (const XML_Char *name,
const XML_Char *elems[], GLuint count) {
const XML_Char **found;
found = bsearch (&name, elems, count, sizeof (XML_Char *), compare);
if (found)
return found - elems;
else
return count;
}
/** \brief Parse a value of a given type. */
static GLboolean parseValue (driOptionValue *v, driOptionType type,
const XML_Char *string) {
const XML_Char *tail;
/* skip leading white-space */
string += strspn (string, " \f\n\r\t\v");
switch (type) {
case DRI_BOOL:
if (!strcmp (string, "false")) {
v->_bool = GL_FALSE;
tail = string + 5;
} else if (!strcmp (string, "true")) {
v->_bool = GL_TRUE;
tail = string + 4;
}
else
return GL_FALSE;
break;
case DRI_ENUM: /* enum is just a special integer */
case DRI_INT:
v->_int = strtol (string, (char **)&tail, 0);
break;
case DRI_FLOAT:
v->_float = strtod (string, (char **)&tail);
break;
}
if (tail == string)
return GL_FALSE; /* empty string (or containing only white-space) */
/* skip trailing white space */
if (*tail)
tail += strspn (tail, " \f\n\r\t\v");
if (*tail)
return GL_FALSE; /* something left over that is not part of value */
return GL_TRUE;
}
/** \brief Parse a list of ranges of type info->type. */
static GLboolean parseRanges (driOptionInfo *info, const XML_Char *string) {
XML_Char *cp, *range;
GLuint nRanges, i;
driOptionRange *ranges;
XSTRDUP (cp, string);
/* pass 1: determine the number of ranges (number of commas + 1) */
range = cp;
for (nRanges = 1; *range; ++range)
if (*range == ',')
++nRanges;
if ((ranges = MALLOC (nRanges*sizeof(driOptionRange))) == NULL) {
fprintf (stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__);
abort();
}
/* pass 2: parse all ranges into preallocated array */
range = cp;
for (i = 0; i < nRanges; ++i) {
XML_Char *end, *sep;
assert (range);
end = strchr (range, ',');
if (end)
*end = '\0';
sep = strchr (range, ':');
if (sep) { /* non-empty interval */
*sep = '\0';
if (!parseValue (&ranges[i].start, info->type, range) ||
!parseValue (&ranges[i].end, info->type, sep+1))
break;
if (info->type == DRI_INT &&
ranges[i].start._int > ranges[i].end._int)
break;
if (info->type == DRI_FLOAT &&
ranges[i].start._float > ranges[i].end._float)
break;
} else { /* empty interval */
if (!parseValue (&ranges[i].start, info->type, range))
break;
ranges[i].end = ranges[i].start;
}
if (end)
range = end+1;
else
range = NULL;
}
FREE (cp);
if (i < nRanges) {
FREE (ranges);
return GL_FALSE;
} else
assert (range == NULL);
info->nRanges = nRanges;
info->ranges = ranges;
return GL_TRUE;
}
/** \brief Check if a value is in one of info->ranges. */
static GLboolean checkValue (const driOptionValue *v, const driOptionInfo *info) {
GLuint i;
assert (info->type != DRI_BOOL); /* should be caught by the parser */
if (info->nRanges == 0)
return GL_TRUE;
switch (info->type) {
case DRI_ENUM: /* enum is just a special integer */
case DRI_INT:
for (i = 0; i < info->nRanges; ++i)
if (v->_int >= info->ranges[i].start._int &&
v->_int <= info->ranges[i].end._int)
return GL_TRUE;
break;
case DRI_FLOAT:
for (i = 0; i < info->nRanges; ++i)
if (v->_float >= info->ranges[i].start._float &&
v->_float <= info->ranges[i].end._float)
return GL_TRUE;
break;
default:
assert (0); /* should never happen */
}
return GL_FALSE;
}
/** \brief Output a warning message. */
#define XML_WARNING1(msg) do {\
__driUtilMessage ("Warning in %s line %d, column %d: "msg, data->name, \
XML_GetCurrentLineNumber(data->parser), \
XML_GetCurrentColumnNumber(data->parser)); \
} while (0)
#define XML_WARNING(msg,args...) do { \
__driUtilMessage ("Warning in %s line %d, column %d: "msg, data->name, \
XML_GetCurrentLineNumber(data->parser), \
XML_GetCurrentColumnNumber(data->parser), \
args); \
} while (0)
/** \brief Output an error message. */
#define XML_ERROR1(msg) do { \
__driUtilMessage ("Error in %s line %d, column %d: "msg, data->name, \
XML_GetCurrentLineNumber(data->parser), \
XML_GetCurrentColumnNumber(data->parser)); \
} while (0)
#define XML_ERROR(msg,args...) do { \
__driUtilMessage ("Error in %s line %d, column %d: "msg, data->name, \
XML_GetCurrentLineNumber(data->parser), \
XML_GetCurrentColumnNumber(data->parser), \
args); \
} while (0)
/** \brief Output a fatal error message and abort. */
#define XML_FATAL1(msg) do { \
fprintf (stderr, "Fatal error in %s line %d, column %d: "msg"\n", \
data->name, \
XML_GetCurrentLineNumber(data->parser), \
XML_GetCurrentColumnNumber(data->parser)); \
abort();\
} while (0)
#define XML_FATAL(msg,args...) do { \
fprintf (stderr, "Fatal error in %s line %d, column %d: "msg"\n", \
data->name, \
XML_GetCurrentLineNumber(data->parser), \
XML_GetCurrentColumnNumber(data->parser), \
args); \
abort();\
} while (0)
/** \brief Parser context for __driConfigOptions. */
struct OptInfoData {
const char *name;
XML_Parser parser;
driOptionCache *cache;
GLboolean inDriInfo;
GLboolean inSection;
GLboolean inDesc;
GLboolean inOption;
GLboolean inEnum;
int curOption;
};
/** \brief Elements in __driConfigOptions. */
enum OptInfoElem {
OI_DESCRIPTION = 0, OI_DRIINFO, OI_ENUM, OI_OPTION, OI_SECTION, OI_COUNT
};
static const XML_Char *OptInfoElems[] = {
"description", "driinfo", "enum", "option", "section"
};
/** \brief Parse attributes of an enum element.
*
* We're not actually interested in the data. Just make sure this is ok
* for external configuration tools.
*/
static void parseEnumAttr (struct OptInfoData *data, const XML_Char **attr) {
GLuint i;
const XML_Char *value = NULL, *text = NULL;
driOptionValue v;
GLuint opt = data->curOption;
for (i = 0; attr[i]; i += 2) {
if (!strcmp (attr[i], "value")) value = attr[i+1];
else if (!strcmp (attr[i], "text")) text = attr[i+1];
else XML_FATAL("illegal enum attribute: %s.", attr[i]);
}
if (!value) XML_FATAL1 ("value attribute missing in enum.");
if (!text) XML_FATAL1 ("text attribute missing in enum.");
if (!parseValue (&v, data->cache->info[opt].type, value))
XML_FATAL ("illegal enum value: %s.", value);
if (!checkValue (&v, &data->cache->info[opt]))
XML_FATAL ("enum value out of valid range: %s.", value);
}
/** \brief Parse attributes of a description element.
*
* We're not actually interested in the data. Just make sure this is ok
* for external configuration tools.
*/
static void parseDescAttr (struct OptInfoData *data, const XML_Char **attr) {
GLuint i;
const XML_Char *lang = NULL, *text = NULL;
for (i = 0; attr[i]; i += 2) {
if (!strcmp (attr[i], "lang")) lang = attr[i+1];
else if (!strcmp (attr[i], "text")) text = attr[i+1];
else XML_FATAL("illegal description attribute: %s.", attr[i]);
}
if (!lang) XML_FATAL1 ("lang attribute missing in description.");
if (!text) XML_FATAL1 ("text attribute missing in description.");
}
/** \brief Parse attributes of an option element. */
static void parseOptInfoAttr (struct OptInfoData *data, const XML_Char **attr) {
enum OptAttr {OA_DEFAULT = 0, OA_NAME, OA_TYPE, OA_VALID, OA_COUNT};
static const XML_Char *optAttr[] = {"default", "name", "type", "valid"};
const XML_Char *attrVal[OA_COUNT] = {NULL, NULL, NULL, NULL};
const char *defaultVal;
driOptionCache *cache = data->cache;
GLuint opt, i;
for (i = 0; attr[i]; i += 2) {
GLuint attrName = bsearchStr (attr[i], optAttr, OA_COUNT);
if (attrName >= OA_COUNT)
XML_FATAL ("illegal option attribute: %s", attr[i]);
attrVal[attrName] = attr[i+1];
}
if (!attrVal[OA_NAME]) XML_FATAL1 ("name attribute missing in option.");
if (!attrVal[OA_TYPE]) XML_FATAL1 ("type attribute missing in option.");
if (!attrVal[OA_DEFAULT]) XML_FATAL1 ("default attribute missing in option.");
opt = findOption (cache, attrVal[OA_NAME]);
if (cache->info[opt].name)
XML_FATAL ("option %s redefined.", attrVal[OA_NAME]);
data->curOption = opt;
XSTRDUP (cache->info[opt].name, attrVal[OA_NAME]);
if (!strcmp (attrVal[OA_TYPE], "bool"))
cache->info[opt].type = DRI_BOOL;
else if (!strcmp (attrVal[OA_TYPE], "enum"))
cache->info[opt].type = DRI_ENUM;
else if (!strcmp (attrVal[OA_TYPE], "int"))
cache->info[opt].type = DRI_INT;
else if (!strcmp (attrVal[OA_TYPE], "float"))
cache->info[opt].type = DRI_FLOAT;
else
XML_FATAL ("illegal type in option: %s.", attrVal[OA_TYPE]);
defaultVal = getenv (cache->info[opt].name);
if (defaultVal != NULL) {
/* don't use XML_WARNING, we want the user to see this! */
fprintf (stderr,
"ATTENTION: default value of option %s overridden by environment.\n",
cache->info[opt].name);
} else
defaultVal = attrVal[OA_DEFAULT];
if (!parseValue (&cache->values[opt], cache->info[opt].type, defaultVal))
XML_FATAL ("illegal default value: %s.", defaultVal);
if (attrVal[OA_VALID]) {
if (cache->info[opt].type == DRI_BOOL)
XML_FATAL1 ("boolean option with valid attribute.");
if (!parseRanges (&cache->info[opt], attrVal[OA_VALID]))
XML_FATAL ("illegal valid attribute: %s.", attrVal[OA_VALID]);
if (!checkValue (&cache->values[opt], &cache->info[opt]))
XML_FATAL ("default value out of valid range '%s': %s.",
attrVal[OA_VALID], defaultVal);
} else if (cache->info[opt].type == DRI_ENUM) {
XML_FATAL1 ("valid attribute missing in option (mandatory for enums).");
} else {
cache->info[opt].nRanges = 0;
cache->info[opt].ranges = NULL;
}
}
/** \brief Handler for start element events. */
static void optInfoStartElem (void *userData, const XML_Char *name,
const XML_Char **attr) {
struct OptInfoData *data = (struct OptInfoData *)userData;
enum OptInfoElem elem = bsearchStr (name, OptInfoElems, OI_COUNT);
switch (elem) {
case OI_DRIINFO:
if (data->inDriInfo)
XML_FATAL1 ("nested <driinfo> elements.");
if (attr[0])
XML_FATAL1 ("attributes specified on <driinfo> element.");
data->inDriInfo = GL_TRUE;
break;
case OI_SECTION:
if (!data->inDriInfo)
XML_FATAL1 ("<section> must be inside <driinfo>.");
if (data->inSection)
XML_FATAL1 ("nested <section> elements.");
if (attr[0])
XML_FATAL1 ("attributes specified on <section> element.");
data->inSection = GL_TRUE;
break;
case OI_DESCRIPTION:
if (!data->inSection && !data->inOption)
XML_FATAL1 ("<description> must be inside <description> or <option.");
if (data->inDesc)
XML_FATAL1 ("nested <description> elements.");
data->inDesc = GL_TRUE;
parseDescAttr (data, attr);
break;
case OI_OPTION:
if (!data->inSection)
XML_FATAL1 ("<option> must be inside <section>.");
if (data->inDesc)
XML_FATAL1 ("<option> nested in <description> element.");
if (data->inOption)
XML_FATAL1 ("nested <option> elements.");
data->inOption = GL_TRUE;
parseOptInfoAttr (data, attr);
break;
case OI_ENUM:
if (!(data->inOption && data->inDesc))
XML_FATAL1 ("<enum> must be inside <option> and <description>.");
if (data->inEnum)
XML_FATAL1 ("nested <enum> elements.");
data->inEnum = GL_TRUE;
parseEnumAttr (data, attr);
break;
default:
XML_FATAL ("unknown element: %s.", name);
}
}
/** \brief Handler for end element events. */
static void optInfoEndElem (void *userData, const XML_Char *name) {
struct OptInfoData *data = (struct OptInfoData *)userData;
enum OptInfoElem elem = bsearchStr (name, OptInfoElems, OI_COUNT);
switch (elem) {
case OI_DRIINFO:
data->inDriInfo = GL_FALSE;
break;
case OI_SECTION:
data->inSection = GL_FALSE;
break;
case OI_DESCRIPTION:
data->inDesc = GL_FALSE;
break;
case OI_OPTION:
data->inOption = GL_FALSE;
break;
case OI_ENUM:
data->inEnum = GL_FALSE;
break;
default:
assert (0); /* should have been caught by StartElem */
}
}
void driParseOptionInfo (driOptionCache *info) {
XML_Parser p;
int status;
struct OptInfoData userData;
struct OptInfoData *data = &userData;
GLuint nOptions;
/* determine hash table size and allocate memory */
GLuint size, log2size;
for (size = 1, log2size = 0; size < __driNConfigOptions*3/2;
size <<= 1, ++log2size);
info->tableSize = log2size;
info->info = CALLOC (size * sizeof (driOptionInfo));
info->values = CALLOC (size * sizeof (driOptionInfo));
if (info->info == NULL || info->values == NULL) {
fprintf (stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__);
abort();
}
p = XML_ParserCreate ("UTF-8"); /* always UTF-8 */
XML_SetElementHandler (p, optInfoStartElem, optInfoEndElem);
XML_SetUserData (p, data);
userData.name = "__driConfigOptions";
userData.parser = p;
userData.cache = info;
userData.inDriInfo = GL_FALSE;
userData.inSection = GL_FALSE;
userData.inDesc = GL_FALSE;
userData.inOption = GL_FALSE;
userData.inEnum = GL_FALSE;
userData.curOption = -1;
status = XML_Parse (p, __driConfigOptions, strlen (__driConfigOptions), 1);
if (!status)
XML_FATAL ("%s.", XML_ErrorString(XML_GetErrorCode(p)));
XML_ParserFree (p);
/* Check if the actual number of options matches __driNConfigOptions.
* A mismatch is not fatal (a hash table overflow would be) but we
* want the driver developer's attention anyway. */
nOptions = countOptions (info);
if (nOptions != __driNConfigOptions) {
fprintf (stderr,
"Error: __driNConfigOptions (%u) does not match the actual number of options in\n"
" __driConfigOptions (%u).\n",
__driNConfigOptions, nOptions);
}
}
/** \brief Parser context for configuration files. */
struct OptConfData {
const char *name;
XML_Parser parser;
driOptionCache *cache;
GLint screenNum;
const char *driverName, *execName;
GLuint ignoringDevice;
GLuint ignoringApp;
GLuint inDriConf;
GLuint inDevice;
GLuint inApp;
GLuint inOption;
};
/** \brief Elements in configuration files. */
enum OptConfElem {
OC_APPLICATION = 0, OC_DEVICE, OC_DRICONF, OC_OPTION, OC_COUNT
};
static const XML_Char *OptConfElems[] = {
"application", "device", "driconf", "option"
};
/** \brief Parse attributes of a device element. */
static void parseDeviceAttr (struct OptConfData *data, const XML_Char **attr) {
GLuint i;
const XML_Char *driver = NULL, *screen = NULL;
for (i = 0; attr[i]; i += 2) {
if (!strcmp (attr[i], "driver")) driver = attr[i+1];
else if (!strcmp (attr[i], "screen")) screen = attr[i+1];
else XML_WARNING("unkown device attribute: %s.", attr[i]);
}
if (driver && strcmp (driver, data->driverName))
data->ignoringDevice = data->inDevice;
else if (screen) {
driOptionValue screenNum;
if (!parseValue (&screenNum, DRI_INT, screen))
XML_WARNING("illegal screen number: %s.", screen);
else if (screenNum._int != data->screenNum)
data->ignoringDevice = data->inDevice;
}
}
/** \brief Parse attributes of an application element. */
static void parseAppAttr (struct OptConfData *data, const XML_Char **attr) {
GLuint i;
const XML_Char *name = NULL, *exec = NULL;
for (i = 0; attr[i]; i += 2) {
if (!strcmp (attr[i], "name")) name = attr[i+1];
else if (!strcmp (attr[i], "executable")) exec = attr[i+1];
else XML_WARNING("unkown application attribute: %s.", attr[i]);
}
if (exec && strcmp (exec, data->execName))
data->ignoringApp = data->inApp;
}
/** \brief Parse attributes of an option element. */
static void parseOptConfAttr (struct OptConfData *data, const XML_Char **attr) {
GLuint i;
const XML_Char *name = NULL, *value = NULL;
for (i = 0; attr[i]; i += 2) {
if (!strcmp (attr[i], "name")) name = attr[i+1];
else if (!strcmp (attr[i], "value")) value = attr[i+1];
else XML_WARNING("unkown option attribute: %s.", attr[i]);
}
if (!name) XML_WARNING1 ("name attribute missing in option.");
if (!value) XML_WARNING1 ("value attribute missing in option.");
if (name && value) {
driOptionCache *cache = data->cache;
GLuint opt = findOption (cache, name);
if (cache->info[opt].name == NULL)
XML_WARNING ("undefined option: %s.", name);
else if (getenv (cache->info[opt].name))
/* don't use XML_WARNING, we want the user to see this! */
fprintf (stderr, "ATTENTION: option value of option %s ignored.\n",
cache->info[opt].name);
else if (!parseValue (&cache->values[opt], cache->info[opt].type, value))
XML_WARNING ("illegal option value: %s.", value);
}
}
/** \brief Handler for start element events. */
static void optConfStartElem (void *userData, const XML_Char *name,
const XML_Char **attr) {
struct OptConfData *data = (struct OptConfData *)userData;
enum OptConfElem elem = bsearchStr (name, OptConfElems, OC_COUNT);
switch (elem) {
case OC_DRICONF:
if (data->inDriConf)
XML_WARNING1 ("nested <driconf> elements.");
if (attr[0])
XML_WARNING1 ("attributes specified on <driconf> element.");
data->inDriConf++;
break;
case OC_DEVICE:
if (!data->inDriConf)
XML_WARNING1 ("<device> should be inside <driconf>.");
if (data->inDevice)
XML_WARNING1 ("nested <device> elements.");
data->inDevice++;
if (!data->ignoringDevice && !data->ignoringApp)
parseDeviceAttr (data, attr);
break;
case OC_APPLICATION:
if (!data->inDevice)
XML_WARNING1 ("<application> should be inside <device>.");
if (data->inApp)
XML_WARNING1 ("nested <application> elements.");
data->inApp++;
if (!data->ignoringDevice && !data->ignoringApp)
parseAppAttr (data, attr);
break;
case OC_OPTION:
if (!data->inApp)
XML_WARNING1 ("<option> should be inside <application>.");
if (data->inOption)
XML_WARNING1 ("nested <option> elements.");
data->inOption++;
if (!data->ignoringDevice && !data->ignoringApp)
parseOptConfAttr (data, attr);
break;
default:
XML_WARNING ("unknown element: %s.", name);
}
}
/** \brief Handler for end element events. */
static void optConfEndElem (void *userData, const XML_Char *name) {
struct OptConfData *data = (struct OptConfData *)userData;
enum OptConfElem elem = bsearchStr (name, OptConfElems, OC_COUNT);
switch (elem) {
case OC_DRICONF:
data->inDriConf--;
break;
case OC_DEVICE:
if (data->inDevice-- == data->ignoringDevice)
data->ignoringDevice = 0;
break;
case OC_APPLICATION:
if (data->inApp-- == data->ignoringApp)
data->ignoringApp = 0;
break;
case OC_OPTION:
data->inOption--;
break;
default:
/* unknown element, warning was produced on start tag */;
}
}
/** \brief Initialize an option cache based on info */
static void initOptionCache (driOptionCache *cache, driOptionCache *info) {
cache->info = info->info;
cache->tableSize = info->tableSize;
cache->values = MALLOC ((1<<info->tableSize) * sizeof (driOptionValue));
if (cache->values == NULL) {
fprintf (stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__);
abort();
}
memcpy (cache->values, info->values,
(1<<info->tableSize) * sizeof (driOptionValue));
}
/** \brief Parse the named configuration file */
static void parseOneConfigFile (XML_Parser p) {
#define BUF_SIZE 0x1000
struct OptConfData *data = (struct OptConfData *)XML_GetUserData (p);
int status;
int fd;
if ((fd = open (data->name, O_RDONLY)) == -1) {
__driUtilMessage ("Can't open configuration file %s: %s.",
data->name, strerror (errno));
return;
}
while (1) {
int bytesRead;
void *buffer = XML_GetBuffer (p, BUF_SIZE);
if (!buffer) {
__driUtilMessage ("Can't allocate parser buffer.");
break;
}
bytesRead = read (fd, buffer, BUF_SIZE);
if (bytesRead == -1) {
__driUtilMessage ("Error reading from configuration file %s: %s.",
data->name, strerror (errno));
break;
}
status = XML_ParseBuffer (p, bytesRead, bytesRead == 0);
if (!status) {
XML_ERROR ("%s.", XML_ErrorString(XML_GetErrorCode(p)));
break;
}
if (bytesRead == 0)
break;
}
close (fd);
#undef BUF_SIZE
}
void driParseConfigFiles (driOptionCache *cache, driOptionCache *info,
GLint screenNum, const char *driverName) {
char *filenames[2] = {"/etc/drirc", NULL};
char *home;
GLuint i;
struct OptConfData userData;
initOptionCache (cache, info);
userData.cache = cache;
userData.screenNum = screenNum;
userData.driverName = driverName;
#ifndef _SOLO
userData.execName = GET_PROGRAM_NAME();
#else
userData.execName = "Solo";
#endif
if ((home = getenv ("HOME"))) {
GLuint len = strlen (home);
filenames[1] = MALLOC (len + 7+1);
if (filenames[1] == NULL)
__driUtilMessage ("Can't allocate memory for %s/.drirc.", home);
else {
memcpy (filenames[1], home, len);
memcpy (filenames[1] + len, "/.drirc", 7+1);
}
}
for (i = 0; i < 2; ++i) {
XML_Parser p;
if (filenames[i] == NULL)
continue;
p = XML_ParserCreate (NULL); /* use encoding specified by file */
XML_SetElementHandler (p, optConfStartElem, optConfEndElem);
XML_SetUserData (p, &userData);
userData.parser = p;
userData.name = filenames[i];
userData.ignoringDevice = 0;
userData.ignoringApp = 0;
userData.inDriConf = 0;
userData.inDevice = 0;
userData.inApp = 0;
userData.inOption = 0;
parseOneConfigFile (p);
XML_ParserFree (p);
}
if (filenames[1])
FREE (filenames[1]);
}
void driDestroyOptionInfo (driOptionCache *info) {
driDestroyOptionCache (info);
if (info->info) {
GLuint i, size = 1 << info->tableSize;
for (i = 0; i < size; ++i) {
if (info->info[i].name) {
FREE (info->info[i].name);
if (info->info[i].ranges)
FREE (info->info[i].ranges);
}
}
FREE (info->info);
}
}
void driDestroyOptionCache (driOptionCache *cache) {
if (cache->values)
FREE (cache->values);
}
GLboolean driCheckOption (const driOptionCache *cache, const char *name,
driOptionType type) {
GLuint i = findOption (cache, name);
return cache->info[i].name != NULL && cache->info[i].type == type;
}
GLboolean driQueryOptionb (const driOptionCache *cache, const char *name) {
GLuint i = findOption (cache, name);
/* make sure the option is defined and has the correct type */
assert (cache->info[i].name != NULL);
assert (cache->info[i].type == DRI_BOOL);
return cache->values[i]._bool;
}
GLint driQueryOptioni (const driOptionCache *cache, const char *name) {
GLuint i = findOption (cache, name);
/* make sure the option is defined and has the correct type */
assert (cache->info[i].name != NULL);
assert (cache->info[i].type == DRI_INT || cache->info[i].type == DRI_ENUM);
return cache->values[i]._int;
}
GLfloat driQueryOptionf (const driOptionCache *cache, const char *name) {
GLuint i = findOption (cache, name);
/* make sure the option is defined and has the correct type */
assert (cache->info[i].name != NULL);
assert (cache->info[i].type == DRI_FLOAT);
return cache->values[i]._float;
}

125
src/mesa/drivers/dri/common/xmlconfig.h Normal file
View file

@ -0,0 +1,125 @@
/*
* XML DRI client-side driver configuration
* Copyright (C) 2003 Felix Kuehling
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* FELIX KUEHLING, OR ANY OTHER CONTRIBUTORS 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 xmlconfig.h
* \brief Driver-independent client-side part of the XML configuration
* \author Felix Kuehling
*/
#ifndef __XMLCONFIG_H
#define __XMLCONFIG_H
/** \brief Option data types */
typedef enum driOptionType {
DRI_BOOL, DRI_ENUM, DRI_INT, DRI_FLOAT
} driOptionType;
/** \brief Option value */
typedef union driOptionValue {
GLboolean _bool; /**< \brief Boolean */
GLint _int; /**< \brief Integer or Enum */
GLfloat _float; /**< \brief Floating-point */
} driOptionValue;
/** \brief Single range of valid values
*
* For empty ranges (a single value) start == end */
typedef struct driOptionRange {
driOptionValue start; /**< \brief Start */
driOptionValue end; /**< \brief End */
} driOptionRange;
/** \brief Information about an option */
typedef struct driOptionInfo {
char *name; /**< \brief Name */
driOptionType type; /**< \brief Type */
driOptionRange *ranges; /**< \brief Array of ranges */
GLuint nRanges; /**< \brief Number of ranges */
} driOptionInfo;
/** \brief Option cache
*
* \li One in <driver>Screen caching option info and the default values
* \li One in each <driver>Context with the actual values for that context */
typedef struct driOptionCache {
driOptionInfo *info;
/**< \brief Array of option infos
*
* Points to the same array in the screen and all contexts */
driOptionValue *values;
/**< \brief Array of option values
*
* \li Default values in screen
* \li Actual values in contexts
*/
GLuint tableSize;
/**< \brief Size of the arrays
*
* Depending on the hash function this may differ from __driNConfigOptions.
* In the current implementation it's not actually a size but log2(size).
* The value is the same in the screen and all contexts. */
} driOptionCache;
/** \brief XML document describing available options
*
* This must be defined in a driver-specific soure file. xmlpool.h
* defines helper macros and common options. */
extern const char __driConfigOptions[];
/** \brief The number of options supported by a driver
*
* This is used to choose an appropriate hash table size. So any value
* larger than the actual number of options will work. */
extern const GLuint __driNConfigOptions;
/** \brief Parse XML option info from __driConfigOptions
*
* To be called in <driver>CreateScreen */
void driParseOptionInfo (driOptionCache *info);
/** \brief Initialize option cache from info and parse configuration files
*
* To be called in <driver>CreateContext. screenNum and driverName select
* device sections. */
void driParseConfigFiles (driOptionCache *cache, driOptionCache *info,
GLint screenNum, const char *driverName);
/** \brief Destroy option info
*
* To be called in <driver>DestroyScreen */
void driDestroyOptionInfo (driOptionCache *info);
/** \brief Destroy option cache
*
* To be called in <driver>DestroyContext */
void driDestroyOptionCache (driOptionCache *cache);
/** \brief Check if there exists a certain option */
GLboolean driCheckOption (const driOptionCache *cache, const char *name,
driOptionType type);
/** \brief Query a boolean option value */
GLboolean driQueryOptionb (const driOptionCache *cache, const char *name);
/** \brief Query an integer option value */
GLint driQueryOptioni (const driOptionCache *cache, const char *name);
/** \brief Query a floating-point option value */
GLfloat driQueryOptionf (const driOptionCache *cache, const char *name);
#endif

203
src/mesa/drivers/dri/common/xmlpool.h Normal file
View file

@ -0,0 +1,203 @@
/* -*- mode:C; coding: mult-utf-8-unix -*-
*
* !!! Important: This file is encoded in UTF-8 !!!
*
* Note (Emacs): You need Mule. In Debian the package is called
* mule-ucs.
*
* Note (Emacs): You may have to enable multibyte characters in the
* Mule customization group or by setting
* default-enable-multibyte-characters to t in your .emacs:
*/
/*
* XML DRI client-side driver configuration
* Copyright (C) 2003 Felix Kuehling
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* FELIX KUEHLING, OR ANY OTHER CONTRIBUTORS 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 xmlpool.h
* \brief Pool of common options
* \author Felix Kuehling
*
* This file defines macros that can be used to construct driConfigOptions
* in the drivers.
*/
#ifndef __XMLPOOL_H
#define __XMLPOOL_H
/*
* generic macros
*/
/** \brief Begin __driConfigOptions */
#define DRI_CONF_BEGIN \
"<driinfo>\n"
/** \brief End __driConfigOptions */
#define DRI_CONF_END \
"</driinfo>\n"
/** \brief Begin a section of related options */
#define DRI_CONF_SECTION_BEGIN \
"<section>\n"
/** \brief End a section of related options */
#define DRI_CONF_SECTION_END \
"</section>\n"
/** \brief Begin an option definition */
#define DRI_CONF_OPT_BEGIN(name,type,def) \
"<option name=\""#name"\" type=\""#type"\" default=\""#def"\">\n"
/** \brief Begin an option definition with restrictions on valid values */
#define DRI_CONF_OPT_BEGIN_V(name,type,def,valid) \
"<option name=\""#name"\" type=\""#type"\" default=\""#def"\" valid=\""valid"\">\n"
/** \brief End an option description */
#define DRI_CONF_OPT_END \
"</option>\n"
/** \brief A verbal description in a specified language (empty version) */
#define DRI_CONF_DESC(lang,text) \
"<description lang=\""#lang"\" text=\""text"\"/>\n"
/** \brief A verbal description in a specified language */
#define DRI_CONF_DESC_BEGIN(lang,text) \
"<description lang=\""#lang"\" text=\""text"\">\n"
/** \brief End a description */
#define DRI_CONF_DESC_END \
"</description>\n"
/** \brief A verbal description of an enum value */
#define DRI_CONF_ENUM(value,text) \
"<enum value=\""#value"\" text=\""text"\"/>\n"
/*
* predefined option sections and options with multi-lingual descriptions
*/
/** \brief Debugging options */
#define DRI_CONF_SECTION_DEBUG \
DRI_CONF_SECTION_BEGIN \
DRI_CONF_DESC(en,"Debugging") \
DRI_CONF_DESC(de,"Fehlersuche")
#define DRI_CONF_NO_RAST(def) \
DRI_CONF_OPT_BEGIN(no_rast,bool,def) \
DRI_CONF_DESC(en,"Disable 3D acceleration") \
DRI_CONF_DESC(de,"3D-Beschleunigung abschalten") \
DRI_CONF_OPT_END
#define DRI_CONF_PERFORMANCE_BOXES(def) \
DRI_CONF_OPT_BEGIN(performance_boxes,bool,def) \
DRI_CONF_DESC(en,"Show performance boxes") \
DRI_CONF_DESC(de,"Zeige Performanceboxen") \
DRI_CONF_OPT_END
#define DRI_CONF_DEBUG_DMA(def) \
DRI_CONF_OPT_BEGIN(debug_dma,bool,def) \
DRI_CONF_DESC(en,"Debug DMA buffers") \
DRI_CONF_DESC(de,"DMA Puffer debuggen") \
DRI_CONF_OPT_END
/** \brief Texture-related options */
#define DRI_CONF_SECTION_QUALITY \
DRI_CONF_SECTION_BEGIN \
DRI_CONF_DESC(en,"Image Quality") \
DRI_CONF_DESC(de,"Bildqualität")
#define DRI_CONF_PREFERRED_BPT(def,valid) \
DRI_CONF_OPT_BEGIN_V(preferred_bpt,enum,def,valid) \
DRI_CONF_DESC_BEGIN(en,"Preferred texture color depth") \
DRI_CONF_ENUM(0,"Same as frame buffer") \
DRI_CONF_DESC_END \
DRI_CONF_DESC_BEGIN(de,"Bevorzugte Textur Farbtiefe") \
DRI_CONF_ENUM(0,"So wie der Framebuffer") \
DRI_CONF_DESC_END \
DRI_CONF_OPT_END
/** \brief Performance-related options */
#define DRI_CONF_SECTION_PERFORMANCE \
DRI_CONF_SECTION_BEGIN \
DRI_CONF_DESC(en,"Performance") \
DRI_CONF_DESC(de,"Leistung")
#define DRI_CONF_TCL_SW 0
#define DRI_CONF_TCL_PIPELINED 1
#define DRI_CONF_TCL_VTXFMT 2
#define DRI_CONF_TCL_CODEGEN 3
#define DRI_CONF_TCL_MODE(def) \
DRI_CONF_OPT_BEGIN_V(tcl_mode,enum,def,"0:3") \
DRI_CONF_DESC_BEGIN(en,"TCL mode (Transformation, Clipping, Lighting)") \
DRI_CONF_ENUM(0,"Software") \
DRI_CONF_ENUM(1,"TCL stage in MESA pipeline") \
DRI_CONF_ENUM(2,"Bypass MESA's pipeline") \
DRI_CONF_ENUM(3,"Bypass MESA's pipeline with state-based code generation") \
DRI_CONF_DESC_END \
DRI_CONF_DESC_BEGIN(de,"TCL Modus (Transformation, Clipping, Licht)") \
DRI_CONF_ENUM(0,"Software") \
DRI_CONF_ENUM(1,"TCL Stufe in MESA Pipeline") \
DRI_CONF_ENUM(2,"Umgehe MESA's Pipeline") \
DRI_CONF_ENUM(3,"Umgehe MESA's Pipeline mit zustandsbasierter Codegenerierung") \
DRI_CONF_DESC_END \
DRI_CONF_OPT_END
#define DRI_CONF_FTHROTTLE_BUSY 0
#define DRI_CONF_FTHROTTLE_USLEEPS 1
#define DRI_CONF_FTHROTTLE_IRQS 2
#define DRI_CONF_FTHROTTLE_MODE(def) \
DRI_CONF_OPT_BEGIN_V(fthrottle_mode,enum,def,"0:2") \
DRI_CONF_DESC_BEGIN(en,"Frame throttling") \
DRI_CONF_ENUM(0,"Busy waiting") \
DRI_CONF_ENUM(1,"Usleeps") \
DRI_CONF_ENUM(2,"Software interrupts") \
DRI_CONF_DESC_END \
DRI_CONF_DESC_BEGIN(de,"Framethrottling") \
DRI_CONF_ENUM(0,"Aktives Warten") \
DRI_CONF_ENUM(1,"Usleeps") \
DRI_CONF_ENUM(2,"Sortware Interrutps") \
DRI_CONF_DESC_END \
DRI_CONF_OPT_END
#define DRI_CONF_VBLANK_NEVER 0
#define DRI_CONF_VBLANK_DEF_INTERVAL_0 1
#define DRI_CONF_VBLANK_DEF_INTERVAL_1 2
#define DRI_CONF_VBLANK_ALWAYS_SYNC 3
#define DRI_CONF_VBLANK_MODE(def) \
DRI_CONF_OPT_BEGIN_V(vblank_mode,enum,def,"0:3") \
DRI_CONF_DESC_BEGIN(en,"Synchronization with vertical refresh (swap intervals)") \
DRI_CONF_ENUM(0,"Never, FPS rulez!") \
DRI_CONF_ENUM(1,"Application preference, default interval 0") \
DRI_CONF_ENUM(2,"Application preference, default interval 1") \
DRI_CONF_ENUM(3,"Application preference, always synchronize with refresh") \
DRI_CONF_DESC_END \
DRI_CONF_DESC_BEGIN(de,"Synchronisation mit dem vertikalen Bildaufbau (swap intervals)") \
DRI_CONF_ENUM(0,"Niemals, immer die maximale Framerate") \
DRI_CONF_ENUM(1,"Anwendung entscheidet, Standardinterval 0") \
DRI_CONF_ENUM(2,"Anwendung entscheidet, Standardinterval 1") \
DRI_CONF_ENUM(3,"Anwendung entscheidet, immer mit Bildaufbau synchronisieren") \
DRI_CONF_DESC_END \
DRI_CONF_OPT_END
#endif

6
src/mesa/drivers/dri/mga/Makefile.X11
View file

@ -1,4 +1,4 @@
# $Id: Makefile.X11,v 1.4 2003/10/20 02:17:33 jonsmirl Exp $
# $Id: Makefile.X11,v 1.5 2003/10/21 06:05:41 jonsmirl Exp $
# Mesa 3-D graphics library
# Version: 5.0
@ -31,7 +31,8 @@ DRIVER_SOURCES = mgadd.c \
../common/mm.c \
../common/utils.c \
../common/texmem.c \
../common/vblank.c
../common/vblank.c \
../common/xmlconfig.c
FULL_DRIVER_SOURCES = \
mgapixel.c \
@ -39,6 +40,7 @@ FULL_DRIVER_SOURCES = \
mgatex.c \
mgatexmem.c \
mga_texstate.c \
mga_texcombine.c \
mgavb.c \
mga_xmesa.c

647
src/mesa/drivers/dri/mga/mga_texcombine.c Normal file
View file

@ -0,0 +1,647 @@
/*
* Copyright (c) 2003 Ville Syrjala
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS 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:
* Ville Syrjala <syrjala@sci.fi>
*/
#include "glheader.h"
#include "mgacontext.h"
#include "mgatex.h"
#include "mgaregs.h"
/*
* GL_ARB_texture_env_combine
* GL_EXT_texture_env_combine
* GL_ARB_texture_env_crossbar
* GL_ATI_texture_env_combine3
*/
#define ARG_DISABLE 0xffffffff
#define MGA_ARG1 0
#define MGA_ARG2 1
#define MGA_ALPHA 2
GLboolean mgaUpdateTextureEnvCombine( GLcontext *ctx, int unit )
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
const int source = mmesa->tmu_source[unit];
const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[source];
GLuint *reg = ((GLuint *)&mmesa->setup.tdualstage0 + unit);
GLuint numColorArgs = 0, numAlphaArgs = 0;
GLuint arg1[3], arg2[3], alpha[3];
int args[3];
int i;
switch (texUnit->CombineModeRGB) {
case GL_REPLACE:
numColorArgs = 1;
break;
case GL_MODULATE:
case GL_ADD:
case GL_ADD_SIGNED:
case GL_SUBTRACT:
numColorArgs = 2;
break;
case GL_INTERPOLATE:
case GL_MODULATE_ADD_ATI:
case GL_MODULATE_SIGNED_ADD_ATI:
case GL_MODULATE_SUBTRACT_ATI:
numColorArgs = 3;
break;
default:
return GL_FALSE;
}
switch (texUnit->CombineModeA) {
case GL_REPLACE:
numAlphaArgs = 1;
break;
case GL_MODULATE:
case GL_ADD:
case GL_ADD_SIGNED:
case GL_SUBTRACT:
numAlphaArgs = 2;
break;
default:
return GL_FALSE;
}
/* Start fresh :) */
*reg = 0;
/* COLOR */
for (i = 0; i < 3; i++) {
arg1[i] = 0;
arg2[i] = 0;
alpha[i] = 0;
}
for (i = 0;i < numColorArgs; i++) {
switch (texUnit->CombineSourceRGB[i]) {
case GL_TEXTURE:
arg1[i] |= 0;
arg2[i] |= ARG_DISABLE;
alpha[i] |= TD0_color_alpha_currtex;
break;
case GL_TEXTURE0:
if (source == 0) {
arg1[i] |= 0;
arg2[i] |= ARG_DISABLE;
alpha[i] |= TD0_color_alpha_currtex;
} else {
if (ctx->Texture._EnabledUnits != 0x03) {
/* disable texturing */
mmesa->setup.dwgctl &= DC_opcod_MASK;
mmesa->setup.dwgctl |= DC_opcod_trap;
mmesa->hw.alpha_sel = AC_alphasel_diffused;
/* return GL_TRUE since we don't need a fallback */
return GL_TRUE;
}
arg1[i] |= ARG_DISABLE;
arg2[i] |= ARG_DISABLE;
alpha[i] |= TD0_color_alpha_prevtex;
}
break;
case GL_TEXTURE1:
if (source == 0) {
if (ctx->Texture._EnabledUnits != 0x03) {
/* disable texturing */
mmesa->setup.dwgctl &= DC_opcod_MASK;
mmesa->setup.dwgctl |= DC_opcod_trap;
mmesa->hw.alpha_sel = AC_alphasel_diffused;
/* return GL_TRUE since we don't need a fallback */
return GL_TRUE;
}
arg1[i] |= ARG_DISABLE;
/* G400 specs (TDUALSTAGE0) */
arg2[i] |= TD0_color_arg2_prevstage;
alpha[i] |= TD0_color_alpha_prevstage;
} else {
arg1[i] |= 0;
arg2[i] |= ARG_DISABLE;
alpha[i] |= TD0_color_alpha_currtex;
}
break;
case GL_CONSTANT:
arg1[i] |= ARG_DISABLE;
arg2[i] |= TD0_color_arg2_fcol;
alpha[i] |= TD0_color_alpha_fcol;
break;
case GL_PRIMARY_COLOR:
arg1[i] |= ARG_DISABLE;
/* G400 specs (TDUALSTAGE1) */
if (unit == 0 || (mmesa->setup.tdualstage0 &
((TD0_color_sel_mul & TD0_color_sel_add) |
(TD0_alpha_sel_mul & TD0_alpha_sel_add)))) {
arg2[i] |= TD0_color_arg2_diffuse;
alpha[i] |= TD0_color_alpha_diffuse;
} else {
arg2[i] |= ARG_DISABLE;
alpha[i] |= ARG_DISABLE;
}
break;
case GL_PREVIOUS:
arg1[i] |= ARG_DISABLE;
if (unit == 0) {
arg2[i] |= TD0_color_arg2_diffuse;
alpha[i] |= TD0_color_alpha_diffuse;
} else {
arg2[i] |= TD0_color_arg2_prevstage;
alpha[i] |= TD0_color_alpha_prevstage;
}
break;
default:
return GL_FALSE;
}
switch (texUnit->CombineOperandRGB[i]) {
case GL_SRC_COLOR:
arg1[i] |= 0;
arg2[i] |= 0;
alpha[i] |= ARG_DISABLE;
break;
case GL_ONE_MINUS_SRC_COLOR:
arg1[i] |= TD0_color_arg1_inv_enable;
arg2[i] |= TD0_color_arg2_inv_enable;
alpha[i] |= ARG_DISABLE;
break;
case GL_SRC_ALPHA:
arg1[i] |= TD0_color_arg1_replicatealpha_enable;
arg2[i] |= TD0_color_arg2_replicatealpha_enable;
alpha[i] |= 0;
break;
case GL_ONE_MINUS_SRC_ALPHA:
arg1[i] |= (TD0_color_arg1_replicatealpha_enable |
TD0_color_arg1_inv_enable);
arg2[i] |= (TD0_color_arg2_replicatealpha_enable |
TD0_color_arg2_inv_enable);
alpha[i] |= (TD0_color_alpha1inv_enable |
TD0_color_alpha2inv_enable);
break;
}
}
switch (texUnit->CombineModeRGB) {
case GL_MODULATE_ADD_ATI:
case GL_MODULATE_SIGNED_ADD_ATI:
/* Special handling for ATI_texture_env_combine3.
* If Arg1 == Arg0 or Arg1 == Arg2 we can use arg1 or arg2 as input for
* both multiplier and adder.
*/
/* Arg1 == arg1 */
if (arg1[1] == arg1[0]) {
if ((arg1[1] | arg2[2]) != ARG_DISABLE) {
*reg |= arg1[1] | arg2[2];
args[0] = MGA_ARG1; args[1] = MGA_ARG1; args[2] = MGA_ARG2;
break;
} else
if ((arg1[1] | alpha[2]) != ARG_DISABLE) {
*reg |= arg1[1] | alpha[2];
args[0] = MGA_ARG1; args[1] = MGA_ARG1; args[2] = MGA_ALPHA;
break;
}
}
if (arg1[1] == arg1[2]) {
if ((arg1[1] | arg2[0]) != ARG_DISABLE) {
*reg |= arg1[1] | arg2[0];
args[0] = MGA_ARG2; args[1] = MGA_ARG1; args[2] = MGA_ARG1;
break;
} else
if ((arg1[1] | alpha[0]) != ARG_DISABLE) {
*reg |= arg1[1] | alpha[0];
args[0] = MGA_ALPHA; args[1] = MGA_ARG1; args[2] = MGA_ARG1;
break;
}
}
/* fallthrough */
case GL_MODULATE_SUBTRACT_ATI:
/* Arg1 == arg2 */
if (arg2[1] == arg2[0]) {
if ((arg2[1] | arg1[2]) != ARG_DISABLE) {
*reg |= arg2[1] | arg1[2];
args[0] = MGA_ARG2; args[1] = MGA_ARG2; args[2] = MGA_ARG1;
break;
} else
if ((arg2[1] | alpha[2]) != ARG_DISABLE) {
*reg |= arg2[1] | alpha[2];
args[0] = MGA_ARG2; args[1] = MGA_ARG2; args[2] = MGA_ALPHA;
break;
}
}
if (arg2[1] == arg2[2]) {
if ((arg2[1] | arg1[0]) != ARG_DISABLE) {
*reg |= arg2[1] | arg1[0];
args[0] = MGA_ARG1; args[1] = MGA_ARG2; args[2] = MGA_ARG2;
break;
} else
if ((arg2[1] | alpha[0]) != ARG_DISABLE) {
*reg |= arg2[1] | alpha[0];
args[0] = MGA_ALPHA; args[1] = MGA_ARG2; args[2] = MGA_ARG2;
break;
}
}
/* fallthrough */
default:
/* Find working combo of arg1, arg2 and alpha.
*
* Keep the Arg0 != alpha cases first since there's
* no way to get alpha out by itself (GL_REPLACE).
*
* Keep the Arg2 == alpha cases first because only alpha has the
* capabilities to function as Arg2 (GL_INTERPOLATE). Also good for
* GL_ADD, GL_ADD_SIGNED, GL_SUBTRACT since we can't get alpha to the
* adder.
*
* Keep the Arg1 == alpha cases last for GL_MODULATE_ADD_ATI,
* GL_MODULATE_SIGNED_ADD_ATI. Again because we can't get alpha to the
* adder.
*
* GL_MODULATE_SUBTRACT_ATI needs special treatment since it requires
* that Arg1 == arg2. This requirement clashes with those of other modes.
*/
if ((arg1[0] | arg2[1] | alpha[2]) != ARG_DISABLE) {
*reg |= arg1[0] | arg2[1] | alpha[2];
args[0] = MGA_ARG1; args[1] = MGA_ARG2; args[2] = MGA_ALPHA;
} else
if ((arg1[1] | arg2[0] | alpha[2]) != ARG_DISABLE &&
texUnit->CombineModeRGB != GL_MODULATE_SUBTRACT_ATI) {
*reg |= arg1[1] | arg2[0] | alpha[2];
args[0] = MGA_ARG2; args[1] = MGA_ARG1; args[2] = MGA_ALPHA;
} else
if ((arg1[1] | arg2[2] | alpha[0]) != ARG_DISABLE &&
texUnit->CombineModeRGB != GL_MODULATE_SUBTRACT_ATI) {
*reg |= arg1[1] | arg2[2] | alpha[0];
args[0] = MGA_ALPHA; args[1] = MGA_ARG1; args[2] = MGA_ARG2;
} else
if ((arg1[2] | arg2[1] | alpha[0]) != ARG_DISABLE) {
*reg |= arg1[2] | arg2[1] | alpha[0];
args[0] = MGA_ALPHA; args[1] = MGA_ARG2; args[2] = MGA_ARG1;
} else
if ((arg1[0] | arg2[2] | alpha[1]) != ARG_DISABLE) {
*reg |= arg1[0] | arg2[2] | alpha[1];
args[0] = MGA_ARG1; args[1] = MGA_ALPHA; args[2] = MGA_ARG2;
} else
if ((arg1[2] | arg2[0] | alpha[1]) != ARG_DISABLE) {
*reg |= arg1[2] | arg2[0] | alpha[1];
args[0] = MGA_ARG2; args[1] = MGA_ALPHA; args[2] = MGA_ARG1;
} else {
/* nothing suitable */
return GL_FALSE;
}
}
switch (texUnit->CombineModeRGB) {
case GL_REPLACE:
if (texUnit->CombineScaleShiftRGB) {
return GL_FALSE;
}
if (args[0] == MGA_ARG1) {
*reg |= TD0_color_sel_arg1;
} else if (args[0] == MGA_ARG2) {
*reg |= TD0_color_sel_arg2;
} else if (args[0] == MGA_ALPHA) {
/* Can't get alpha out by itself */
return GL_FALSE;
}
break;
case GL_MODULATE:
if (texUnit->CombineScaleShiftRGB == 1) {
*reg |= TD0_color_modbright_2x;
} else if (texUnit->CombineScaleShiftRGB == 2) {
*reg |= TD0_color_modbright_4x;
}
*reg |= TD0_color_sel_mul;
if (args[0] == MGA_ALPHA || args[1] == MGA_ALPHA) {
if (args[0] == MGA_ARG1 || args[1] == MGA_ARG1) {
*reg |= TD0_color_arg2mul_alpha2;
} else if (args[0] == MGA_ARG2 || args[1] == MGA_ARG2) {
*reg |= TD0_color_arg1mul_alpha1;
}
}
break;
case GL_ADD_SIGNED:
*reg |= TD0_color_addbias_enable;
/* fallthrough */
case GL_ADD:
if (args[0] == MGA_ALPHA || args[1] == MGA_ALPHA){
/* Can't get alpha to the adder */
return GL_FALSE;
}
if (texUnit->CombineScaleShiftRGB == 1) {
*reg |= TD0_color_add2x_enable;
} else if (texUnit->CombineScaleShiftRGB == 2) {
return GL_FALSE;
}
*reg |= (TD0_color_add_add |
TD0_color_sel_add);
break;
case GL_INTERPOLATE:
if (args[2] != MGA_ALPHA) {
/* Only alpha can function as Arg2 */
return GL_FALSE;
}
if (texUnit->CombineScaleShiftRGB == 1) {
*reg |= TD0_color_add2x_enable;
} else if (texUnit->CombineScaleShiftRGB == 2) {
return GL_FALSE;
}
*reg |= (TD0_color_arg1mul_alpha1 |
TD0_color_blend_enable |
TD0_color_arg1add_mulout |
TD0_color_arg2add_mulout |
TD0_color_add_add |
TD0_color_sel_add);
/* Have to do this with xor since GL_ONE_MINUS_SRC_ALPHA may have
* already touched this bit.
*/
*reg ^= TD0_color_alpha1inv_enable;
if (args[0] == MGA_ARG2) {
/* Swap arguments */
*reg ^= (TD0_color_arg1mul_alpha1 |
TD0_color_arg2mul_alpha2 |
TD0_color_alpha1inv_enable |
TD0_color_alpha2inv_enable);
}
if (ctx->Texture._EnabledUnits != 0x03) {
/* Linear blending mode needs dualtex enabled */
*(reg+1) = (TD0_color_arg2_prevstage |
TD0_color_sel_arg2 |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_arg2);
mmesa->dualtex_env = GL_TRUE;
}
break;
case GL_SUBTRACT:
if (args[0] == MGA_ALPHA || args[1] == MGA_ALPHA) {
/* Can't get alpha to the adder */
return GL_FALSE;
}
if (texUnit->CombineScaleShiftRGB == 1) {
*reg |= TD0_color_add2x_enable;
} else if (texUnit->CombineScaleShiftRGB == 2) {
return GL_FALSE;
}
*reg |= (TD0_color_add_sub |
TD0_color_sel_add);
if (args[0] == MGA_ARG2) {
/* Swap arguments */
*reg ^= (TD0_color_arg1_inv_enable |
TD0_color_arg2_inv_enable);
}
break;
case GL_MODULATE_SIGNED_ADD_ATI:
*reg |= TD0_color_addbias_enable;
/* fallthrough */
case GL_MODULATE_ADD_ATI:
if (args[1] == MGA_ALPHA) {
/* Can't get alpha to the adder */
return GL_FALSE;
}
if (texUnit->CombineScaleShiftRGB == 1) {
*reg |= TD0_color_add2x_enable;
} else if (texUnit->CombineScaleShiftRGB == 2) {
return GL_FALSE;
}
*reg |= (TD0_color_add_add |
TD0_color_sel_add);
if (args[1] == args[0] || args[1] == args[2]) {
*reg |= TD0_color_arg1add_mulout;
if (args[0] == MGA_ALPHA || args[2] == MGA_ALPHA)
*reg |= TD0_color_arg1mul_alpha1;
if (args[1] == MGA_ARG1) {
/* Swap adder arguments */
*reg ^= (TD0_color_arg1add_mulout |
TD0_color_arg2add_mulout);
if (args[0] == MGA_ALPHA || args[2] == MGA_ALPHA) {
/* Swap multiplier arguments */
*reg ^= (TD0_color_arg1mul_alpha1 |
TD0_color_arg2mul_alpha2);
}
}
} else {
*reg |= (TD0_color_arg2mul_alpha2 |
TD0_color_arg1add_mulout);
if (args[1] == MGA_ARG1) {
/* Swap arguments */
*reg ^= (TD0_color_arg1mul_alpha1 |
TD0_color_arg2mul_alpha2 |
TD0_color_arg1add_mulout |
TD0_color_arg2add_mulout);
}
}
break;
case GL_MODULATE_SUBTRACT_ATI:
if (args[1] != MGA_ARG2) {
/* Can't swap arguments */
return GL_FALSE;
}
if (texUnit->CombineScaleShiftRGB == 1) {
*reg |= TD0_color_add2x_enable;
} else if (texUnit->CombineScaleShiftRGB == 2) {
return GL_FALSE;
}
*reg |= (TD0_color_add_sub |
TD0_color_sel_add);
if (args[1] == args[0] || args[1] == args[2]) {
*reg |= TD0_color_arg1add_mulout;
if (args[0] == MGA_ALPHA || args[2] == MGA_ALPHA)
*reg |= TD0_color_arg1mul_alpha1;
} else {
*reg |= (TD0_color_arg2mul_alpha2 |
TD0_color_arg1add_mulout);
}
break;
}
/* ALPHA */
for (i = 0; i < 2; i++) {
arg1[i] = 0;
arg2[i] = 0;
}
for (i = 0; i < numAlphaArgs; i++) {
switch (texUnit->CombineSourceA[i]) {
case GL_TEXTURE:
arg1[i] |= 0;
arg2[i] |= ARG_DISABLE;
break;
case GL_TEXTURE0:
if (source == 0) {
arg1[i] |= 0;
arg2[i] |= ARG_DISABLE;
} else {
if (ctx->Texture._EnabledUnits != 0x03) {
/* disable texturing */
mmesa->setup.dwgctl &= DC_opcod_MASK;
mmesa->setup.dwgctl |= DC_opcod_trap;
mmesa->hw.alpha_sel = AC_alphasel_diffused;
/* return GL_TRUE since we don't need a fallback */
return GL_TRUE;
}
arg1[i] |= ARG_DISABLE;
arg2[i] |= TD0_alpha_arg2_prevtex;
}
break;
case GL_TEXTURE1:
if (source == 0) {
if (ctx->Texture._EnabledUnits != 0x03) {
/* disable texturing */
mmesa->setup.dwgctl &= DC_opcod_MASK;
mmesa->setup.dwgctl |= DC_opcod_trap;
mmesa->hw.alpha_sel = AC_alphasel_diffused;
/* return GL_TRUE since we don't need a fallback */
return GL_TRUE;
}
arg1[i] |= ARG_DISABLE;
/* G400 specs (TDUALSTAGE0) */
arg2[i] |= TD0_alpha_arg2_prevstage;
} else {
arg1[i] |= 0;
arg2[i] |= ARG_DISABLE;
}
break;
case GL_CONSTANT:
arg1[i] |= ARG_DISABLE;
arg2[i] |= TD0_alpha_arg2_fcol;
break;
case GL_PRIMARY_COLOR:
arg1[i] |= ARG_DISABLE;
/* G400 specs (TDUALSTAGE1) */
if (unit == 0 || (mmesa->setup.tdualstage0 &
((TD0_color_sel_mul & TD0_color_sel_add) |
(TD0_alpha_sel_mul & TD0_alpha_sel_add)))) {
arg2[i] |= TD0_alpha_arg2_diffuse;
} else {
arg2[i] |= ARG_DISABLE;
}
break;
case GL_PREVIOUS:
arg1[i] |= ARG_DISABLE;
if (unit == 0) {
arg2[i] |= TD0_alpha_arg2_diffuse;
} else {
arg2[i] |= TD0_alpha_arg2_prevstage;
}
break;
default:
return GL_FALSE;
}
switch (texUnit->CombineOperandA[i]) {
case GL_SRC_ALPHA:
arg1[i] |= 0;
arg2[i] |= 0;
break;
case GL_ONE_MINUS_SRC_ALPHA:
arg1[i] |= TD0_alpha_arg1_inv_enable;
arg2[i] |= TD0_alpha_arg2_inv_enable;
break;
}
}
/* Find a working combo of arg1 and arg2 */
if ((arg1[0] | arg2[1]) != ARG_DISABLE) {
*reg |= arg1[0] | arg2[1];
args[0] = MGA_ARG1; args[1] = MGA_ARG2;
} else
if ((arg1[1] | arg2[0]) != ARG_DISABLE) {
*reg |= arg1[1] | arg2[0];
args[0] = MGA_ARG2; args[1] = MGA_ARG1;
} else {
/* nothing suitable */
return GL_FALSE;
}
switch (texUnit->CombineModeA) {
case GL_REPLACE:
if (texUnit->CombineScaleShiftA) {
return GL_FALSE;
}
if (args[0] == MGA_ARG1){
*reg |= TD0_alpha_sel_arg1;
} else if (args[0] == MGA_ARG2) {
*reg |= TD0_alpha_sel_arg2;
}
break;
case GL_MODULATE:
if (texUnit->CombineScaleShiftA == 1) {
*reg |= TD0_alpha_modbright_2x;
} else if (texUnit->CombineScaleShiftA == 2) {
*reg |= TD0_alpha_modbright_4x;
}
*reg |= TD0_alpha_sel_mul;
break;
case GL_ADD_SIGNED:
*reg |= TD0_alpha_addbias_enable;
/* fallthrough */
case GL_ADD:
if (texUnit->CombineScaleShiftA == 1) {
*reg |= TD0_alpha_add2x_enable;
} else if (texUnit->CombineScaleShiftA == 2) {
return GL_FALSE;
}
*reg |= (TD0_alpha_add_enable |
TD0_alpha_sel_add);
break;
case GL_SUBTRACT:
if (texUnit->CombineScaleShiftA == 1) {
*reg |= TD0_alpha_add2x_enable;
} else if (texUnit->CombineScaleShiftA == 2) {
return GL_FALSE;
}
*reg |= (TD0_alpha_add_disable |
TD0_alpha_sel_add);
if (args[0] == MGA_ARG2) {
/* Swap arguments */
*reg ^= (TD0_alpha_arg1_inv_enable |
TD0_alpha_arg2_inv_enable);
}
break;
}
return GL_TRUE;
}

538
src/mesa/drivers/dri/mga/mga_texstate.c
View file

@ -52,6 +52,8 @@ static const unsigned TMC_tformat[ TMC_nr_tformat ] =
[MESA_FORMAT_RGB565] = TMC_tformat_tw16 | TMC_takey_1 | TMC_tamask_0,
[MESA_FORMAT_ARGB4444] = TMC_tformat_tw12 | TMC_takey_1 | TMC_tamask_0,
[MESA_FORMAT_ARGB1555] = TMC_tformat_tw15 | TMC_takey_1 | TMC_tamask_0,
[MESA_FORMAT_AL88] = TMC_tformat_tw8al | TMC_takey_1 | TMC_tamask_0,
[MESA_FORMAT_I8] = TMC_tformat_tw8a | TMC_takey_1 | TMC_tamask_0,
[MESA_FORMAT_CI8] = TMC_tformat_tw8 | TMC_takey_1 | TMC_tamask_0,
[MESA_FORMAT_YCBCR] = TMC_tformat_tw422uyvy | TMC_takey_1 | TMC_tamask_0,
[MESA_FORMAT_YCBCR_REV] = TMC_tformat_tw422 | TMC_takey_1 | TMC_tamask_0,
@ -67,7 +69,7 @@ mgaSetTexImages( mgaContextPtr mmesa,
GLint totalSize;
GLint width, height;
GLint i;
GLint firstLevel, lastLevel, numLevels;
GLint numLevels;
GLint log2Width, log2Height;
GLuint txformat = 0;
GLint ofs;
@ -81,6 +83,8 @@ mgaSetTexImages( mgaContextPtr mmesa,
case MESA_FORMAT_RGB565: txformat = TMC_tformat_tw16; break;
case MESA_FORMAT_ARGB4444: txformat = TMC_tformat_tw12; break;
case MESA_FORMAT_ARGB1555: txformat = TMC_tformat_tw15; break;
case MESA_FORMAT_AL88: txformat = TMC_tformat_tw8al; break;
case MESA_FORMAT_I8: txformat = TMC_tformat_tw8a; break;
case MESA_FORMAT_CI8: txformat = TMC_tformat_tw8; break;
case MESA_FORMAT_YCBCR: txformat = TMC_tformat_tw422uyvy; break;
case MESA_FORMAT_YCBCR_REV: txformat = TMC_tformat_tw422; break;
@ -101,39 +105,21 @@ mgaSetTexImages( mgaContextPtr mmesa,
#endif /* MGA_USE_TABLE_FOR_FORMAT */
if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) {
/* GL_NEAREST and GL_LINEAR only care about GL_TEXTURE_BASE_LEVEL.
*/
driCalculateTextureFirstLastLevel( (driTextureObject *) t );
log2Width = tObj->Image[t->base.firstLevel]->WidthLog2;
log2Height = tObj->Image[t->base.firstLevel]->HeightLog2;
firstLevel = lastLevel = tObj->BaseLevel;
} else {
/* Compute which mipmap levels we really want to send to the hardware.
* This depends on the base image size, GL_TEXTURE_MIN_LOD,
* GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL.
* Yes, this looks overly complicated, but it's all needed.
*/
width = tObj->Image[t->base.firstLevel]->Width;
height = tObj->Image[t->base.firstLevel]->Height;
firstLevel = tObj->BaseLevel + (GLint)(tObj->MinLod + 0.5);
firstLevel = MAX2(firstLevel, tObj->BaseLevel);
lastLevel = tObj->BaseLevel + (GLint)(tObj->MaxLod + 0.5);
lastLevel = MAX2(lastLevel, tObj->BaseLevel);
lastLevel = MIN2(lastLevel, tObj->BaseLevel + baseImage->MaxLog2);
lastLevel = MIN2(lastLevel, tObj->MaxLevel);
lastLevel = MAX2(firstLevel, lastLevel); /* need at least one level */
}
log2Width = tObj->Image[firstLevel]->WidthLog2;
log2Height = tObj->Image[firstLevel]->HeightLog2;
width = tObj->Image[firstLevel]->Width;
height = tObj->Image[firstLevel]->Height;
numLevels = MIN2( lastLevel - firstLevel + 1,
numLevels = MIN2( t->base.lastLevel - t->base.firstLevel + 1,
MGA_IS_G200(mmesa) ? G200_TEX_MAXLEVELS : G400_TEX_MAXLEVELS);
totalSize = 0;
for ( i = 0 ; i < numLevels ; i++ ) {
const struct gl_texture_image * const texImage = tObj->Image[i+firstLevel];
const struct gl_texture_image * const texImage =
tObj->Image[ i + t->base.firstLevel ];
if ( (texImage == NULL)
|| ((i != 0)
@ -149,13 +135,9 @@ mgaSetTexImages( mgaContextPtr mmesa,
baseImage->TexFormat->TexelBytes) + 31) & ~31;
}
numLevels = i;
lastLevel = firstLevel + numLevels - 1;
/* save these values */
t->base.firstLevel = firstLevel;
t->base.lastLevel = lastLevel;
numLevels = i;
t->base.lastLevel = t->base.firstLevel + numLevels - 1;
t->base.totalSize = totalSize;
/* setup hardware register values */
@ -225,7 +207,7 @@ static void mgaUpdateTextureEnvG200( GLcontext *ctx, GLuint unit )
t->setup.texctl2 |= TMC_decalblend_enable;
break;
case GL_BLEND:
FALLBACK( ctx, MGA_FALLBACK_TEXTURE, GL_TRUE );
t->texenv_fallback = GL_TRUE;
break;
default:
break;
@ -251,12 +233,124 @@ static const GLuint g400_color_combine[][MGA_MAX_COMBFUNC] =
(0),
/* GL_REPLACE
* Cv = Cs
* Av = Af
*/
(TD0_color_sel_arg1 |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_arg2),
/* GL_MODULATE
* Cv = Cf Cs
* Av = Af
*/
(TD0_color_arg2_diffuse |
TD0_color_sel_mul |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_arg2),
/* GL_DECAL
* Cv = Cs
* Av = Af
*/
(TD0_color_sel_arg1 |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_arg2),
/* GL_BLEND (Cc=0.0)
* Cv = Cf ( 1 - Cs )
* Av = Af
*/
(TD0_color_arg1_inv_enable |
TD0_color_arg2_diffuse |
TD0_color_sel_mul |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_arg2),
/* GL_ADD
* Cv = Cf + Cs
* Av = Af
*/
(TD0_color_arg2_diffuse |
TD0_color_add_add |
TD0_color_sel_add |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_arg2),
},
/* Unit 1:
*/
{
/* Disable combiner stage
*/
(0),
/* GL_REPLACE
* Cv = Cs
* Av = Ap
*/
(TD0_color_sel_arg1 |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_arg2),
/* GL_MODULATE
* Cv = Cp Cs
* Av = Ap
*/
(TD0_color_arg2_prevstage |
TD0_color_sel_mul |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_arg2),
/* GL_DECAL
* Cv = Cs
* Av = Ap
*/
(TD0_color_sel_arg1 |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_arg2),
/* GL_BLEND (Cc=0.0)
* Cv = Cp ( 1 - Cs )
* Av = Ap
*/
(TD0_color_arg1_inv_enable |
TD0_color_arg2_prevstage |
TD0_color_sel_mul |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_arg2),
/* GL_ADD
* Cv = Cp + Cs
* Av = Ap
*/
(TD0_color_arg2_prevstage |
TD0_color_add_add |
TD0_color_sel_add |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_arg2),
},
};
static const GLuint g400_color_alpha_combine[][MGA_MAX_COMBFUNC] =
{
/* Unit 0:
*/
{
/* Disable combiner stage
*/
(0),
/* GL_REPLACE
* Cv = Cs
* Av = As
*/
(TD0_color_sel_arg1 |
TD0_alpha_sel_arg1),
/* GL_MODULATE
* Cv = Cf Cs
* Av = Af As
*/
(TD0_color_arg2_diffuse |
TD0_color_sel_mul |
@ -264,16 +358,35 @@ static const GLuint g400_color_combine[][MGA_MAX_COMBFUNC] =
TD0_alpha_sel_mul),
/* GL_DECAL
* tmp = Cf ( 1 - As )
* Cv = tmp + Cs As
* Av = Af
*/
(TD0_color_sel_arg1 |
(TD0_color_arg2_diffuse |
TD0_color_alpha_currtex |
TD0_color_alpha1inv_enable |
TD0_color_arg1mul_alpha1 |
TD0_color_blend_enable |
TD0_color_arg1add_mulout |
TD0_color_arg2add_mulout |
TD0_color_add_add |
TD0_color_sel_add |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_arg2),
/* GL_BLEND
/* GL_BLEND (Cc=0.0)
* Cv = Cf ( 1 - Cs )
* Av = Af As
*/
(0),
(TD0_color_arg1_inv_enable |
TD0_color_arg2_diffuse |
TD0_color_sel_mul |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_mul),
/* GL_ADD
* Cv = Cf + Cs
* Av = Af As
*/
(TD0_color_arg2_diffuse |
TD0_color_add_add |
@ -290,33 +403,53 @@ static const GLuint g400_color_combine[][MGA_MAX_COMBFUNC] =
(0),
/* GL_REPLACE
* Cv = Cs
* Av = As
*/
(TD0_color_sel_arg1 |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_arg2 ),
TD0_alpha_sel_arg1),
/* GL_MODULATE
* Cv = Cp Cs
* Av = Ap As
*/
(TD0_color_arg2_prevstage |
TD0_color_alpha_prevstage |
TD0_color_sel_mul |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_mul),
/* GL_DECAL
* tmp = Cp ( 1 - As )
* Cv = tmp + Cs As
* Av = Ap
*/
(TD0_color_sel_arg1 |
(TD0_color_arg2_prevstage |
TD0_color_alpha_currtex |
TD0_color_alpha1inv_enable |
TD0_color_arg1mul_alpha1 |
TD0_color_blend_enable |
TD0_color_arg1add_mulout |
TD0_color_arg2add_mulout |
TD0_color_add_add |
TD0_color_sel_add |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_arg2),
/* GL_BLEND
/* GL_BLEND (Cc=0.0)
* Cv = Cp ( 1 - Cs )
* Av = Ap As
*/
(0),
(TD0_color_arg1_inv_enable |
TD0_color_arg2_prevstage |
TD0_color_sel_mul |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_mul),
/* GL_ADD
* Cv = Cp + Cs
* Av = Ap As
*/
(TD0_color_arg2_prevstage |
TD0_color_alpha_prevstage |
TD0_color_add_add |
TD0_color_sel_add |
TD0_alpha_arg2_prevstage |
@ -334,20 +467,25 @@ static const GLuint g400_alpha_combine[][MGA_MAX_COMBFUNC] =
(0),
/* GL_REPLACE
* Cv = Cf
* Av = As
*/
(TD0_color_sel_arg2 |
TD0_color_arg2_diffuse |
(TD0_color_arg2_diffuse |
TD0_color_sel_arg2 |
TD0_alpha_sel_arg1),
/* GL_MODULATE
* FIXME: Is this correct?
* Cv = Cf
* Av = Af As
*/
(TD0_color_arg2_diffuse |
TD0_color_sel_mul |
TD0_color_sel_arg2 |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_mul),
/* GL_DECAL
/* GL_DECAL (undefined)
* Cv = Cf
* Av = Af
*/
(TD0_color_arg2_diffuse |
TD0_color_sel_arg2 |
@ -355,16 +493,20 @@ static const GLuint g400_alpha_combine[][MGA_MAX_COMBFUNC] =
TD0_alpha_sel_arg2),
/* GL_BLEND
* Cv = Cf
* Av = Af As
*/
(TD0_color_arg2_diffuse |
TD0_color_sel_mul |
TD0_color_sel_arg2 |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_mul),
/* GL_ADD
* Cv = Cf
* Av = Af As
*/
(TD0_color_arg2_diffuse |
TD0_color_sel_mul |
TD0_color_sel_arg2 |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_mul),
},
@ -377,21 +519,25 @@ static const GLuint g400_alpha_combine[][MGA_MAX_COMBFUNC] =
(0),
/* GL_REPLACE
* Cv = Cp
* Av = As
*/
(TD0_color_sel_arg2 |
TD0_color_arg2_diffuse |
(TD0_color_arg2_prevstage |
TD0_color_sel_arg2 |
TD0_alpha_sel_arg1),
/* GL_MODULATE
* FIXME: Is this correct?
* Cv = Cp
* Av = Ap As
*/
(TD0_color_arg2_prevstage |
TD0_color_alpha_prevstage |
TD0_color_sel_mul |
TD0_color_sel_arg2 |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_mul),
/* GL_DECAL
/* GL_DECAL (undefined)
* Cv = Cp
* Av = Ap
*/
(TD0_color_arg2_prevstage |
TD0_color_sel_arg2 |
@ -399,16 +545,20 @@ static const GLuint g400_alpha_combine[][MGA_MAX_COMBFUNC] =
TD0_alpha_sel_arg2),
/* GL_BLEND
* Cv = Cp
* Av = Ap As
*/
(TD0_color_arg2_diffuse |
TD0_color_sel_mul |
TD0_alpha_arg2_diffuse |
(TD0_color_arg2_prevstage |
TD0_color_sel_arg2 |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_mul),
/* GL_ADD
* Cv = Cp
* Av = Ap As
*/
(TD0_color_arg2_prevstage |
TD0_color_sel_mul |
TD0_color_sel_arg2 |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_mul),
},
@ -421,77 +571,69 @@ static void mgaUpdateTextureEnvG400( GLcontext *ctx, GLuint unit )
const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[source];
const struct gl_texture_object *tObj = texUnit->_Current;
GLuint *reg = ((GLuint *)&mmesa->setup.tdualstage0 + unit);
mgaTextureObjectPtr t;
GLenum format;
if ( tObj != ctx->Texture.Unit[source].Current2D || !tObj )
if ( !tObj ||
(tObj != ctx->Texture.Unit[source].Current2D &&
tObj != ctx->Texture.Unit[source].CurrentRect) )
return;
format = tObj->Image[tObj->BaseLevel]->Format;
t = (mgaTextureObjectPtr) tObj->DriverData;
switch (ctx->Texture.Unit[source].EnvMode) {
case GL_REPLACE:
if (format == GL_RGB || format == GL_LUMINANCE) {
*reg = g400_color_combine[unit][MGA_REPLACE];
}
else if (format == GL_ALPHA) {
if (format == GL_ALPHA) {
*reg = g400_alpha_combine[unit][MGA_REPLACE];
}
else {
*reg = (TD0_color_sel_arg1 |
TD0_alpha_sel_arg1 );
} else if (format == GL_RGB || format == GL_LUMINANCE) {
*reg = g400_color_combine[unit][MGA_REPLACE];
} else {
*reg = g400_color_alpha_combine[unit][MGA_REPLACE];
}
break;
case GL_MODULATE:
if (format == GL_ALPHA) {
*reg = g400_alpha_combine[unit][MGA_MODULATE];
} else if (format == GL_RGB || format == GL_LUMINANCE) {
*reg = g400_color_combine[unit][MGA_MODULATE];
} else {
*reg = g400_color_alpha_combine[unit][MGA_MODULATE];
}
break;
case GL_DECAL:
if (format == GL_RGB) {
*reg = g400_color_combine[unit][MGA_DECAL];
}
else if ( format == GL_RGBA ) {
#if 0
if (unit == 0) {
/* this doesn't work */
*reg = (TD0_color_arg2_diffuse |
TD0_color_alpha_currtex |
TD0_color_alpha2inv_enable |
TD0_color_arg2mul_alpha2 |
TD0_color_arg1mul_alpha1 |
TD0_color_blend_enable |
TD0_color_arg1add_mulout |
TD0_color_arg2add_mulout |
TD0_color_add_add |
TD0_color_sel_mul |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_arg2 );
}
else {
*reg = (TD0_color_arg2_prevstage |
TD0_color_alpha_currtex |
TD0_color_alpha2inv_enable |
TD0_color_arg2mul_alpha2 |
TD0_color_arg1mul_alpha1 |
TD0_color_add_add |
TD0_color_sel_add |
} else if (format == GL_RGBA) {
*reg = g400_color_alpha_combine[unit][MGA_DECAL];
if (ctx->Texture._EnabledUnits != 0x03) {
/* Linear blending mode needs dual texturing enabled */
*(reg+1) = (TD0_color_arg2_prevstage |
TD0_color_sel_arg2 |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_arg2);
mmesa->dualtex_env = GL_TRUE;
}
#else
/* s/w fallback, pretty sure we can't do in h/w */
FALLBACK( ctx, MGA_FALLBACK_TEXTURE, GL_TRUE );
if ( MGA_DEBUG & DEBUG_VERBOSE_FALLBACK )
fprintf( stderr, "FALLBACK: GL_DECAL RGBA texture, unit=%d\n",
unit );
#endif
}
else {
} else {
/* Undefined */
*reg = g400_alpha_combine[unit][MGA_DECAL];
}
break;
case GL_ADD:
if (format == GL_INTENSITY) {
if (format == GL_ALPHA) {
*reg = g400_alpha_combine[unit][MGA_ADD];
} else if (format == GL_RGB || format == GL_LUMINANCE) {
*reg = g400_color_combine[unit][MGA_ADD];
} else if (format == GL_RGBA || format == GL_LUMINANCE_ALPHA) {
*reg = g400_color_alpha_combine[unit][MGA_ADD];
} else if (format == GL_INTENSITY) {
/* Cv = Cf + Cs
* Av = Af + As
*/
if (unit == 0) {
*reg = (TD0_color_arg2_diffuse |
TD0_color_add_add |
@ -499,8 +641,7 @@ static void mgaUpdateTextureEnvG400( GLcontext *ctx, GLuint unit )
TD0_alpha_arg2_diffuse |
TD0_alpha_add_enable |
TD0_alpha_sel_add);
}
else {
} else {
*reg = (TD0_color_arg2_prevstage |
TD0_color_add_add |
TD0_color_sel_add |
@ -509,55 +650,157 @@ static void mgaUpdateTextureEnvG400( GLcontext *ctx, GLuint unit )
TD0_alpha_sel_add);
}
}
else if (format == GL_ALPHA) {
*reg = g400_alpha_combine[unit][MGA_ADD];
}
else {
*reg = g400_color_combine[unit][MGA_ADD];
}
break;
case GL_BLEND:
if (format == GL_ALPHA) {
*reg = g400_alpha_combine[unit][MGA_BLEND];
}
else {
FALLBACK( ctx, MGA_FALLBACK_TEXTURE, GL_TRUE );
if ( MGA_DEBUG & DEBUG_VERBOSE_FALLBACK )
fprintf( stderr, "FALLBACK: GL_BLEND envcolor=0x%08x\n",
mmesa->envcolor );
/* Do singletexture GL_BLEND with 'all ones' env-color
* by using both texture units. Multitexture gl_blend
* is a fallback.
} else {
if (mmesa->blend_flags & MGA_BLEND_RGB_ZERO) {
if (format == GL_RGB || format == GL_LUMINANCE) {
*reg = g400_color_combine[unit][MGA_BLEND];
} else if (format == GL_RGBA || format == GL_LUMINANCE_ALPHA) {
*reg = g400_color_alpha_combine[unit][MGA_BLEND];
} else if (format == GL_INTENSITY) {
if (mmesa->blend_flags & MGA_BLEND_ALPHA_ZERO) {
/* Cv = Cf ( 1 - Cs )
* Av = Af ( 1 - As )
*/
if (unit == 0) {
/* Part 1: R1 = Rf ( 1 - Rt )
* A1 = Af At
*reg = (TD0_color_arg1_inv_enable |
TD0_color_arg2_diffuse |
TD0_color_sel_mul |
TD0_alpha_arg1_inv_enable |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_mul);
} else {
*reg = (TD0_color_arg1_inv_enable |
TD0_color_arg2_prevstage |
TD0_color_sel_mul |
TD0_alpha_arg1_inv_enable |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_mul);
}
} else if (mmesa->blend_flags & MGA_BLEND_ALPHA_ONE &&
ctx->Texture._EnabledUnits != 0x03) {
/* C1 = Cf ( 1 - Cs )
* A1 = Af ( 1 - As )
*/
*reg = ( TD0_color_arg2_diffuse |
TD0_color_arg1_inv_enable |
*reg = (TD0_color_arg1_inv_enable |
TD0_color_arg2_diffuse |
TD0_color_sel_mul |
TD0_alpha_arg1_inv_enable |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_mul);
/* Cv = C1
* Av = A1 + As
*/
*(reg+1) = (TD0_color_arg2_prevstage |
TD0_color_sel_arg2 |
TD0_alpha_arg2_prevstage |
TD0_alpha_add_enable |
TD0_alpha_sel_add);
mmesa->dualtex_env = GL_TRUE;
} else {
t->texenv_fallback = GL_TRUE;
}
}
} else if (mmesa->blend_flags & MGA_BLEND_RGB_ONE &&
ctx->Texture._EnabledUnits != 0x03) {
if (format == GL_RGB || format == GL_LUMINANCE) {
/* C1 = Cf ( 1 - Cs )
* A1 = Af
*/
*reg = (TD0_color_arg1_inv_enable |
TD0_color_arg2_diffuse |
TD0_color_sel_mul |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_arg1);
} else {
/* Part 2: R2 = R1 + Rt
* A2 = A1
TD0_alpha_sel_arg2);
/* Cv = C1 + Cs
* Av = A1
*/
*reg = ( TD0_color_arg2_prevstage |
*(reg+1) = (TD0_color_arg2_prevstage |
TD0_color_add_add |
TD0_color_sel_add |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_arg2);
mmesa->dualtex_env = GL_TRUE;
} else if (format == GL_RGBA || format == GL_LUMINANCE_ALPHA) {
/* C1 = Cf ( 1 - Cs )
* A1 = Af As
*/
*reg = (TD0_color_arg1_inv_enable |
TD0_color_arg2_diffuse |
TD0_color_sel_mul |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_mul);
/* Cv = C1 + Cs
* Av = A1
*/
*(reg+1) = (TD0_color_arg2_prevstage |
TD0_color_add_add |
TD0_color_sel_add |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_arg2);
mmesa->dualtex_env = GL_TRUE;
} else if (format == GL_INTENSITY) {
if (mmesa->blend_flags & MGA_BLEND_ALPHA_ZERO) {
/* C1 = Cf ( 1 - Cs )
* A1 = Af ( 1 - As )
*/
*reg = (TD0_color_arg1_inv_enable |
TD0_color_arg2_diffuse |
TD0_color_sel_mul |
TD0_alpha_arg1_inv_enable |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_mul);
/* Cv = C1 + Cs
* Av = A1
*/
*(reg+1) = (TD0_color_arg2_prevstage |
TD0_color_add_add |
TD0_color_sel_add |
TD0_alpha_arg2_prevstage |
TD0_alpha_sel_arg2);
mmesa->dualtex_env = GL_TRUE;
} else if (mmesa->blend_flags & MGA_BLEND_ALPHA_ONE) {
/* C1 = Cf ( 1 - Cs )
* A1 = Af ( 1 - As )
*/
*reg = (TD0_color_arg1_inv_enable |
TD0_color_arg2_diffuse |
TD0_color_sel_mul |
TD0_alpha_arg1_inv_enable |
TD0_alpha_arg2_diffuse |
TD0_alpha_sel_mul);
/* Cv = C1 + Cs
* Av = A1 + As
*/
*(reg+1) = (TD0_color_arg2_prevstage |
TD0_color_add_add |
TD0_color_sel_add |
TD0_alpha_arg2_prevstage |
TD0_alpha_add_enable |
TD0_alpha_sel_add);
mmesa->dualtex_env = GL_TRUE;
} else {
t->texenv_fallback = GL_TRUE;
}
}
} else {
t->texenv_fallback = GL_TRUE;
}
}
break;
case GL_COMBINE_EXT:
if (!mgaUpdateTextureEnvCombine(ctx, unit))
t->texenv_fallback = GL_TRUE;
break;
default:
break;
}
}
static void disable_tex( GLcontext *ctx, int unit )
{
mgaContextPtr mmesa = MGA_CONTEXT( ctx );
@ -573,7 +816,7 @@ static void disable_tex( GLcontext *ctx, int unit )
mmesa->CurrentTexObj[unit] = NULL;
}
if ( unit != 0 ) {
if ( unit != 0 && !mmesa->dualtex_env ) {
mmesa->setup.tdualstage1 = mmesa->setup.tdualstage0;
}
@ -586,7 +829,7 @@ static void disable_tex( GLcontext *ctx, int unit )
mmesa->dirty |= MGA_UPLOAD_CONTEXT | (MGA_UPLOAD_TEX0 << unit);
}
static GLboolean enable_tex_2d( GLcontext *ctx, int unit )
static GLboolean enable_tex( GLcontext *ctx, int unit )
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
const int source = mmesa->tmu_source[unit];
@ -649,6 +892,14 @@ static GLboolean update_tex_common( GLcontext *ctx, int unit )
t->setup.texctl2 |= TMC_dualtex_enable;
}
t->texenv_fallback = GL_FALSE;
/* Set this before mgaUpdateTextureEnvG400() since
* GL_ARB_texture_env_crossbar may have to disable texturing.
*/
mmesa->setup.dwgctl &= DC_opcod_MASK;
mmesa->setup.dwgctl |= DC_opcod_texture_trap;
/* FIXME: The Radeon has some cached state so that it can avoid calling
* FIXME: UpdateTextureEnv in some cases. Is that possible here?
*/
@ -680,13 +931,10 @@ static GLboolean update_tex_common( GLcontext *ctx, int unit )
mgaUpdateTextureEnvG200( ctx, unit );
}
mmesa->setup.dwgctl &= DC_opcod_MASK;
mmesa->setup.dwgctl |= DC_opcod_texture_trap;
mmesa->dirty |= MGA_UPLOAD_CONTEXT | (MGA_UPLOAD_TEX0 << unit);
FALLBACK( ctx, MGA_FALLBACK_BORDER_MODE, t->border_fallback );
return !t->border_fallback;
return !t->border_fallback && !t->texenv_fallback;
}
@ -697,8 +945,9 @@ static GLboolean updateTextureUnit( GLcontext *ctx, int unit )
const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[source];
if ( texUnit->_ReallyEnabled == TEXTURE_2D_BIT) {
return(enable_tex_2d( ctx, unit ) &&
if ( texUnit->_ReallyEnabled == TEXTURE_2D_BIT ||
texUnit->_ReallyEnabled == TEXTURE_RECT_BIT ) {
return(enable_tex( ctx, unit ) &&
update_tex_common( ctx, unit ));
}
else if ( texUnit->_ReallyEnabled ) {
@ -718,6 +967,7 @@ void mgaUpdateTextureState( GLcontext *ctx )
GLboolean ok;
unsigned i;
mmesa->dualtex_env = GL_FALSE;
/* This works around a quirk with the MGA hardware. If only OpenGL
* TEXTURE1 is enabled, then the hardware TEXTURE0 must be used. The
@ -740,8 +990,4 @@ void mgaUpdateTextureState( GLcontext *ctx )
}
FALLBACK( ctx, MGA_FALLBACK_TEXTURE, !ok );
/* FIXME: I believe that ChooseVertexState should be called here instead of
* FIXME: in mgaDDValidateState.
*/
}

106
src/mesa/drivers/dri/mga/mga_xmesa.c
View file

@ -1,4 +1,4 @@
/* $XFree86: xc/lib/GL/mesa/src/drv/mga/mga_xmesa.c,v 1.18 2002/12/16 16:18:52 dawes Exp $ */
/* $XFree86: xc/lib/GL/mesa/src/drv/mga/mga_xmesa.c,v 1.19 2003/03/26 20:43:49 tsi Exp $ */
/*
* Copyright 2000-2001 VA Linux Systems, Inc.
* All Rights Reserved.
@ -56,11 +56,23 @@
#include "utils.h"
#include "vblank.h"
#include "dri_util.h"
#ifndef _SOLO
#include "glxextensions.h"
#endif
/* MGA configuration
*/
#include "xmlpool.h"
const char __driConfigOptions[] =
DRI_CONF_BEGIN
DRI_CONF_SECTION_PERFORMANCE
DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_DEF_INTERVAL_0)
DRI_CONF_SECTION_END
DRI_CONF_END;
const GLuint __driNConfigOptions = 1;
#ifndef MGA_DEBUG
int MGA_DEBUG = 0;
#endif
@ -97,7 +109,7 @@ mgaInitDriver(__DRIscreenPrivate *sPriv)
&gp, sizeof(gp));
if (ret) {
fprintf(stderr, "drmMgaGetParam (MGA_PARAM_IRQ_NR): %d\n", ret);
free(mgaScreen);
FREE(mgaScreen);
sPriv->private = NULL;
return GL_FALSE;
}
@ -106,22 +118,25 @@ mgaInitDriver(__DRIscreenPrivate *sPriv)
mgaScreen->linecomp_sane = (sPriv->ddxMajor > 1) || (sPriv->ddxMinor > 1)
|| ((sPriv->ddxMinor == 1) && (sPriv->ddxPatch > 0));
#ifndef _SOLO
if ( ! mgaScreen->linecomp_sane ) {
PFNGLXDISABLEEXTENSIONPROC glx_disable_extension;
if ( driCompareGLXAPIVersion( 20030813 ) >= 0 ) {
PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
(PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
void * const psc = sPriv->psc->screenConfigs;
glx_disable_extension = (PFNGLXDISABLEEXTENSIONPROC)
glXGetProcAddress( "__glXDisableExtension" );
if ( glx_enable_extension != NULL ) {
if ( mgaScreen->linecomp_sane ) {
(*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
(*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
(*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
}
if ( glx_disable_extension != NULL ) {
(*glx_disable_extension)( "GLX_SGI_swap_control" );
(*glx_disable_extension)( "GLX_SGI_video_sync" );
(*glx_disable_extension)( "GLX_MESA_swap_control" );
(*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
}
}
#endif
if (serverInfo->chipset != MGA_CARD_TYPE_G200 &&
serverInfo->chipset != MGA_CARD_TYPE_G400) {
free(mgaScreen);
FREE(mgaScreen);
sPriv->private = NULL;
__driUtilMessage("Unrecognized chipset");
return GL_FALSE;
@ -168,7 +183,7 @@ mgaInitDriver(__DRIscreenPrivate *sPriv)
mgaScreen->agp.size,
(drmAddress *)&mgaScreen->agp.map) != 0)
{
free(mgaScreen);
Xfree(mgaScreen);
sPriv->private = NULL;
__driUtilMessage("Couldn't map agp region");
return GL_FALSE;
@ -194,7 +209,7 @@ mgaInitDriver(__DRIscreenPrivate *sPriv)
serverInfo->agpTextureSize,
(drmAddress *)&mgaScreen->texVirtual[MGA_AGP_HEAP]) != 0)
{
free(mgaScreen);
FREE(mgaScreen);
sPriv->private = NULL;
__driUtilMessage("Couldn't map agptexture region");
return GL_FALSE;
@ -214,13 +229,16 @@ mgaInitDriver(__DRIscreenPrivate *sPriv)
mgaScreen->bufs = drmMapBufs(sPriv->fd);
if (!mgaScreen->bufs) {
/*drmUnmap(mgaScreen->agp_tex.map, mgaScreen->agp_tex.size);*/
free(mgaScreen);
FREE(mgaScreen);
sPriv->private = NULL;
__driUtilMessage("Couldn't map dma buffers");
return GL_FALSE;
}
mgaScreen->sarea_priv_offset = serverInfo->sarea_priv_offset;
/* parse information in __driConfigOptions */
driParseOptionInfo (&mgaScreen->optionCache);
return GL_TRUE;
}
@ -234,7 +252,11 @@ mgaDestroyScreen(__DRIscreenPrivate *sPriv)
fprintf(stderr, "mgaDestroyScreen\n");
/*drmUnmap(mgaScreen->agp_tex.map, mgaScreen->agp_tex.size);*/
free(mgaScreen);
/* free all option information */
driDestroyOptionInfo (&mgaScreen->optionCache);
FREE(mgaScreen);
sPriv->private = NULL;
}
@ -263,6 +285,10 @@ static const char * const g400_extensions[] =
"GL_ARB_multitexture",
"GL_ARB_texture_env_add",
"GL_EXT_texture_env_add",
"GL_ARB_texture_env_combine",
"GL_EXT_texture_env_combine",
"GL_ARB_texture_env_crossbar",
"GL_ATI_texture_env_combine3",
"GL_EXT_texture_edge_clamp",
"GL_SGIS_texture_edge_clamp",
#if defined (MESA_packed_depth_stencil)
@ -286,6 +312,7 @@ static const char * const card_extensions[] =
"GL_MESA_ycbcr_texture",
"GL_SGIS_generate_mipmap",
"GL_SGIS_texture_lod",
"GL_NV_texture_rectangle",
NULL
};
@ -353,6 +380,10 @@ mgaCreateContext( const __GLcontextModes *mesaVis,
mmesa->sarea = (void *)saPriv;
mmesa->glBuffer = NULL;
/* Parse configuration files */
driParseConfigFiles (&mmesa->optionCache, &mgaScreen->optionCache,
sPriv->myNum, "mga");
(void) memset( mmesa->texture_heaps, 0, sizeof( mmesa->texture_heaps ) );
make_empty_list( & mmesa->swapped );
@ -388,10 +419,10 @@ mgaCreateContext( const __GLcontextModes *mesaVis,
mmesa->nr_heaps,
& ctx->Const,
4,
11, /* max 2D texture size is 1024x1024 */
11, /* max 2D texture size is 2048x2048 */
0, /* 3D textures unsupported. */
0, /* cube textures unsupported. */
0, /* texture rectangles unsupported. */
11, /* max texture rect size is 2048x2048 */
maxlevels,
GL_FALSE );
@ -487,14 +518,15 @@ mgaCreateContext( const __GLcontextModes *mesaVis,
mmesa->vblank_flags = ((mmesa->mgaScreen->irq == 0)
|| !mmesa->mgaScreen->linecomp_sane)
? VBLANK_FLAG_NO_IRQ : driGetDefaultVBlankFlags();
? VBLANK_FLAG_NO_IRQ : driGetDefaultVBlankFlags(&mmesa->optionCache);
#ifndef _SOLO
mmesa->get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( "__glXGetUST" );
if ( mmesa->get_ust == NULL )
#endif
{
mmesa->get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( (const GLubyte *) "__glXGetUST" );
if ( mmesa->get_ust == NULL ) {
mmesa->get_ust = get_ust_nop;
}
#else
mmesa->get_ust = get_ust_nop;
#endif
(*mmesa->get_ust)( & mmesa->swap_ust );
@ -541,6 +573,9 @@ mgaDestroyContext(__DRIcontextPrivate *driContextPriv)
}
}
/* free the option cache */
driDestroyOptionCache (&mmesa->optionCache);
FREE(mmesa);
}
@ -614,6 +649,7 @@ mgaMakeCurrent(__DRIcontextPrivate *driContextPriv,
mgaContextPtr mmesa = (mgaContextPtr) driContextPriv->driverPrivate;
if (mmesa->driDrawable != driDrawPriv) {
driDrawableInitVBlank( driDrawPriv, mmesa->vblank_flags );
mmesa->driDrawable = driDrawPriv;
mmesa->dirty = ~0;
mmesa->dirty_cliprects = (MGA_FRONT|MGA_BACK);
@ -714,30 +750,6 @@ void *__driCreateScreen(struct DRIDriverRec *driver,
#endif
#ifndef _SOLO
/* This function is called by libGL.so as soon as libGL.so is loaded.
* This is where we'd register new extension functions with the dispatcher.
*/
void
__driRegisterExtensions( void )
{
PFNGLXENABLEEXTENSIONPROC glx_enable_extension;
if ( driCompareGLXAPIVersion( 20030317 ) >= 0 ) {
glx_enable_extension = (PFNGLXENABLEEXTENSIONPROC)
glXGetProcAddress( "__glXEnableExtension" );
if ( glx_enable_extension != NULL ) {
(*glx_enable_extension)( "GLX_SGI_swap_control", GL_FALSE );
(*glx_enable_extension)( "GLX_SGI_video_sync", GL_FALSE );
(*glx_enable_extension)( "GLX_MESA_swap_control", GL_FALSE );
(*glx_enable_extension)( "GLX_MESA_swap_frame_usage", GL_FALSE );
}
}
}
#endif
/**
* Get information about previous buffer swaps.
*/

4
src/mesa/drivers/dri/mga/mga_xmesa.h
View file

@ -36,6 +36,7 @@
#include "mtypes.h"
#include "mgaregs.h"
#include "mga_common.h"
#include "xmlconfig.h"
typedef struct mga_screen_private_s {
@ -78,6 +79,9 @@ typedef struct mga_screen_private_s {
drmRegion primary;
drmRegion buffers;
unsigned int sarea_priv_offset;
/* Configuration cache with default values for all contexts */
driOptionCache optionCache;
} mgaScreenPrivate;

20
src/mesa/drivers/dri/mga/mgacontext.h
View file

@ -38,6 +38,7 @@
#include "mga_sarea.h"
#include "texmem.h"
#include "macros.h"
#include "xmlconfig.h"
#define MGA_SET_FIELD(reg,mask,val) reg = ((reg) & (mask)) | ((val) & ~(mask))
#define MGA_FIELD(field,val) (((val) << (field ## _SHIFT)) & ~(field ## _MASK))
@ -79,10 +80,12 @@ typedef void (*mga_point_func)( mgaContextPtr, mgaVertex * );
/* Reasons why the GL_BLEND fallback mightn't work:
/* GL_BLEND has some limitations
*/
#define MGA_BLEND_ENV_COLOR 0x1
#define MGA_BLEND_MULTITEX 0x2
#define MGA_BLEND_RGB_ZERO 0x1
#define MGA_BLEND_RGB_ONE 0x2
#define MGA_BLEND_ALPHA_ZERO 0x4
#define MGA_BLEND_ALPHA_ONE 0x8
struct mga_texture_object_s;
struct mga_screen_private_s;
@ -149,6 +152,10 @@ typedef struct mga_texture_object_s
* to fallback for GL_CLAMP_TO_BORDER.
*/
GLboolean border_fallback;
/* Depending on multitxturing and environment color
* GL_BLEND may have to be a software fallback.
*/
GLboolean texenv_fallback;
} mgaTextureObject_t;
struct mga_hw_state {
@ -202,10 +209,11 @@ struct mga_context_t {
struct gl_client_array UbyteColor;
struct gl_client_array UbyteSecondaryColor;
/* Support for limited GL_BLEND fallback
/* Support for GL_DECAL and GL_BLEND
*/
unsigned int blend_flags;
unsigned int envcolor;
GLboolean dualtex_env;
/* Rasterization state
*/
@ -299,6 +307,10 @@ struct mga_context_t {
__DRIscreenPrivate *driScreen;
struct mga_screen_private_s *mgaScreen;
MGASAREAPrivPtr sarea;
/* Configuration cache
*/
driOptionCache optionCache;
};
#define MGA_CONTEXT(ctx) ((mgaContextPtr)(ctx->DriverCtx))

3
src/mesa/drivers/dri/mga/mgaioctl.c
View file

@ -26,9 +26,8 @@
* Gareth Hughes <gareth@valinux.com>
*/
/* $XFree86: xc/lib/GL/mesa/src/drv/mga/mgaioctl.c,v 1.16 2002/12/16 16:18:52 dawes Exp $ */
#include <sched.h>
#include <errno.h>
#include <sched.h>
#include "mtypes.h"
#include "macros.h"

73
src/mesa/drivers/dri/mga/mgastate.c
View file

@ -401,7 +401,7 @@ static void mgaDDColorMask(GLcontext *ctx,
*/
static int mgaStipples[16] = {
0xffff1, /* See above note */
0xffff,
0xa5a5,
0x5a5a,
0xa0a0,
@ -425,9 +425,6 @@ static int mgaStipples[16] = {
*
* \param ctx GL rendering context to be affected
* \param mask Pointer to the 32x32 stipple mask
*
* \note the fully opaque pattern (0xffff) has been disabled in order
* to work around a conformance issue.
*/
static void mgaDDPolygonStipple( GLcontext *ctx, const GLubyte *mask )
@ -492,8 +489,7 @@ static void updateSpecularLighting( GLcontext *ctx )
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
unsigned int specen;
specen = (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR &&
ctx->Light.Enabled) ? TMC_specen_enable : 0;
specen = (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) ? TMC_specen_enable : 0;
if ( specen != mmesa->hw.specen ) {
mmesa->hw.specen = specen;
@ -519,14 +515,6 @@ static void mgaDDLightModelfv(GLcontext *ctx, GLenum pname,
}
static void mgaDDShadeModel(GLcontext *ctx, GLenum mode)
{
/* FIXME: This used to FLUSH_BATCH and set MGA_NEW_TEXTURE in new_state,
* FIXME: so I'm not sure what to do here now.
*/
}
/* =============================================================
* Stencil
*/
@ -671,6 +659,12 @@ static void mgaDDStencilOp(GLcontext *ctx, GLenum fail, GLenum zfail,
case GL_DECR:
stencilctl |= SC_szpassop_decrsat;
break;
case GL_INCR_WRAP:
stencilctl |= SC_szpassop_incr;
break;
case GL_DECR_WRAP:
stencilctl |= SC_szpassop_decr;
break;
case GL_INVERT:
stencilctl |= SC_szpassop_invert;
break;
@ -826,8 +820,10 @@ void mgaUpdateRects( mgaContextPtr mmesa, GLuint buffers )
else
mgaXMesaSetBackClipRects( mmesa );
#ifndef _SOLO
sarea->req_drawable = driDrawable->draw;
sarea->req_draw_buffer = mmesa->draw_buffer;
#endif
mgaUpdateClipping( mmesa->glCtx );
mgaCalcViewport( mmesa->glCtx );
@ -888,6 +884,11 @@ static void mgaDDEnable(GLcontext *ctx, GLenum cap, GLboolean state)
mgaContextPtr mmesa = MGA_CONTEXT( ctx );
switch(cap) {
case GL_LIGHTING:
case GL_COLOR_SUM_EXT:
FLUSH_BATCH( mmesa );
updateSpecularLighting( ctx );
break;
case GL_ALPHA_TEST:
FLUSH_BATCH( mmesa );
mmesa->hw.alpha_func_enable = (state) ? ~0 : 0;
@ -1034,24 +1035,23 @@ void mgaEmitHwStateLocked( mgaContextPtr mmesa )
}
if ((mmesa->dirty & MGA_UPLOAD_TEX0) && mmesa->CurrentTexObj[0]) {
mmesa->CurrentTexObj[0]->setup.texctl2 &= ~TMC_specen_enable;
mmesa->CurrentTexObj[0]->setup.texctl2 |= mmesa->hw.specen;
memcpy(&sarea->TexState[0],
&mmesa->CurrentTexObj[0]->setup,
sizeof(sarea->TexState[0]));
}
if ((mmesa->dirty & MGA_UPLOAD_TEX1) && mmesa->CurrentTexObj[1]) {
mmesa->CurrentTexObj[1]->setup.texctl2 &= ~TMC_specen_enable;
mmesa->CurrentTexObj[1]->setup.texctl2 |= mmesa->hw.specen;
memcpy(&sarea->TexState[1],
&mmesa->CurrentTexObj[1]->setup,
sizeof(sarea->TexState[1]));
}
if ( (sarea->TexState[0].texctl2 & TMC_borderen_MASK) !=
if (mmesa->dualtex_env) {
sarea->TexState[0].texctl2 |= TMC_dualtex_enable;
memcpy( &sarea->TexState[1], &sarea->TexState[0],
sizeof(sarea->TexState[0]) );
mmesa->dirty |= MGA_UPLOAD_TEX1|MGA_UPLOAD_TEX0;
} else if ( (sarea->TexState[0].texctl2 & TMC_borderen_MASK) !=
(sarea->TexState[1].texctl2 & TMC_borderen_MASK) ) {
const int borderen = sarea->TexState[1].texctl2 & ~TMC_borderen_MASK;
@ -1070,15 +1070,10 @@ void mgaEmitHwStateLocked( mgaContextPtr mmesa )
mmesa->sarea->dirty |= mmesa->dirty;
mmesa->dirty &= MGA_UPLOAD_CLIPRECTS;
/* This is a bit of a hack but seems to be the best place to ensure
* that separate specular is disabled when not needed.
*/
if (ctx->Texture._EnabledUnits == 0 ||
!ctx->Light.Enabled ||
ctx->Light.Model.ColorControl == GL_SINGLE_COLOR) {
sarea->TexState[0].texctl2 &= ~TMC_specen_enable;
sarea->TexState[1].texctl2 &= ~TMC_specen_enable;
}
sarea->TexState[0].texctl2 |= mmesa->hw.specen;
sarea->TexState[1].texctl2 |= mmesa->hw.specen;
}
@ -1089,11 +1084,14 @@ void mgaEmitHwStateLocked( mgaContextPtr mmesa )
static void mgaDDValidateState( GLcontext *ctx )
{
mgaContextPtr mmesa = MGA_CONTEXT( ctx );
int new_state = mmesa->NewGLState;
FLUSH_BATCH( mmesa );
if (mmesa->NewGLState & _NEW_TEXTURE) {
mgaUpdateTextureState(ctx);
}
if (!mmesa->Fallback) {
if (mmesa->NewGLState & _MGA_NEW_RASTERSETUP) {
mgaChooseVertexState( ctx );
}
@ -1101,9 +1099,6 @@ static void mgaDDValidateState( GLcontext *ctx )
if (mmesa->NewGLState & _MGA_NEW_RENDERSTATE) {
mgaChooseRenderState( ctx );
}
if (new_state & _NEW_TEXTURE) {
mgaUpdateTextureState(ctx);
}
mmesa->NewGLState = 0;
@ -1186,13 +1181,14 @@ void mgaInitState( mgaContextPtr mmesa )
break;
}
mmesa->hw.blend_func = AC_src_one | AC_dst_zero;
mmesa->hw.zmode = DC_zmode_zlt | DC_atype_zi;
mmesa->hw.stencil = (0x0ff << S_smsk_SHIFT) | (0x0ff << S_swtmsk_SHIFT);
mmesa->hw.stencilctl = SC_smode_salways | SC_sfailop_keep
| SC_szfailop_keep | SC_szpassop_keep;
mmesa->hw.stencil_enable = 0;
mmesa->hw.cull = _CULL_NEGATIVE;
mmesa->hw.cull_dualtex = _CULL_POSITIVE;
mmesa->hw.cull = _CULL_DISABLE;
mmesa->hw.cull_dualtex = _CULL_DISABLE;
mmesa->hw.specen = 0;
mmesa->setup.dwgctl = (DC_opcod_trap |
@ -1227,6 +1223,10 @@ void mgaInitState( mgaContextPtr mmesa )
mmesa->setup.tdualstage1 = 0;
mmesa->setup.fcol = 0;
mmesa->dirty |= MGA_UPLOAD_CONTEXT;
mmesa->envcolor = 0;
mmesa->blend_flags = MGA_BLEND_RGB_ZERO | MGA_BLEND_ALPHA_ZERO;
mmesa->dualtex_env = GL_FALSE;
}
@ -1243,7 +1243,6 @@ void mgaDDInitStateFuncs( GLcontext *ctx )
ctx->Driver.DepthMask = mgaDDDepthMask;
ctx->Driver.Fogfv = mgaDDFogfv;
ctx->Driver.Scissor = mgaDDScissor;
ctx->Driver.ShadeModel = mgaDDShadeModel;
ctx->Driver.CullFace = mgaDDCullFaceFrontFace;
ctx->Driver.FrontFace = mgaDDCullFaceFrontFace;
ctx->Driver.ColorMask = mgaDDColorMask;

49
src/mesa/drivers/dri/mga/mgatex.c
View file

@ -221,7 +221,7 @@ mgaChooseTextureFormat( GLcontext *ctx, GLint internalFormat,
case GL_ALPHA16:
case GL_COMPRESSED_ALPHA:
/* FIXME: This will report incorrect component sizes... */
return &_mesa_texformat_argb4444;
return MGA_IS_G400(mmesa) ? &_mesa_texformat_al88 : &_mesa_texformat_argb4444;
case 1:
case GL_LUMINANCE:
@ -231,7 +231,7 @@ mgaChooseTextureFormat( GLcontext *ctx, GLint internalFormat,
case GL_LUMINANCE16:
case GL_COMPRESSED_LUMINANCE:
/* FIXME: This will report incorrect component sizes... */
return &_mesa_texformat_rgb565;
return MGA_IS_G400(mmesa) ? &_mesa_texformat_al88 : &_mesa_texformat_rgb565;
case 2:
case GL_LUMINANCE_ALPHA:
@ -243,7 +243,7 @@ mgaChooseTextureFormat( GLcontext *ctx, GLint internalFormat,
case GL_LUMINANCE16_ALPHA16:
case GL_COMPRESSED_LUMINANCE_ALPHA:
/* FIXME: This will report incorrect component sizes... */
return &_mesa_texformat_argb4444;
return MGA_IS_G400(mmesa) ? &_mesa_texformat_al88 : &_mesa_texformat_argb4444;
case GL_INTENSITY:
case GL_INTENSITY4:
@ -252,7 +252,7 @@ mgaChooseTextureFormat( GLcontext *ctx, GLint internalFormat,
case GL_INTENSITY16:
case GL_COMPRESSED_INTENSITY:
/* FIXME: This will report incorrect component sizes... */
return &_mesa_texformat_argb4444;
return MGA_IS_G400(mmesa) ? &_mesa_texformat_i8 : &_mesa_texformat_argb4444;
case GL_YCBCR_MESA:
if (MGA_IS_G400(mmesa) &&
@ -309,6 +309,7 @@ mgaAllocTexObj( struct gl_texture_object *tObj )
| TF_uvoffset_OGL);
t->border_fallback = GL_FALSE;
t->texenv_fallback = GL_FALSE;
make_empty_list( & t->base );
@ -328,31 +329,31 @@ static void mgaDDTexEnv( GLcontext *ctx, GLenum target,
struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
switch( pname ) {
case GL_TEXTURE_ENV_COLOR: {
GLubyte c[4];
GLuint envColor;
UNCLAMPED_FLOAT_TO_RGBA_CHAN( c, texUnit->EnvColor );
envColor = mgaPackColor( mmesa->mgaScreen->cpp, c[0], c[1], c[2], c[3] );
mmesa->envcolor = PACK_COLOR_8888( c[3], c[0], c[1], c[2] );
if (mmesa->setup.fcol != envColor) {
if (mmesa->setup.fcol != mmesa->envcolor) {
FLUSH_BATCH(mmesa);
mmesa->setup.fcol = envColor;
mmesa->setup.fcol = mmesa->envcolor;
mmesa->dirty |= MGA_UPLOAD_CONTEXT;
mmesa->blend_flags &= ~MGA_BLEND_ENV_COLOR;
mmesa->blend_flags = 0;
/* Actually just require all four components to be
* equal. This permits a single-pass GL_BLEND.
*
* More complex multitexture/multipass fallbacks
* for blend can be done later.
*/
if (mmesa->envcolor != 0x0 && mmesa->envcolor != 0xffffffff)
mmesa->blend_flags |= MGA_BLEND_ENV_COLOR;
if ((mmesa->envcolor & 0xffffff) == 0x0) {
mmesa->blend_flags |= MGA_BLEND_RGB_ZERO;
} else if ((mmesa->envcolor & 0xffffff) == 0xffffff) {
mmesa->blend_flags |= MGA_BLEND_RGB_ONE;
}
if ((mmesa->envcolor >> 24) == 0x0) {
mmesa->blend_flags |= MGA_BLEND_ALPHA_ZERO;
} else if ((mmesa->envcolor >> 24) == 0xff) {
mmesa->blend_flags |= MGA_BLEND_ALPHA_ONE;
}
}
break;
}
@ -445,8 +446,9 @@ mgaDDTexParameter( GLcontext *ctx, GLenum target,
* to do anything now
*/
if ( (t == NULL)
|| (target != GL_TEXTURE_2D) ) {
if ( (t == NULL) ||
(target != GL_TEXTURE_2D &&
target != GL_TEXTURE_RECTANGLE_NV) ) {
return;
}
@ -492,7 +494,8 @@ static void
mgaDDBindTexture( GLcontext *ctx, GLenum target,
struct gl_texture_object *tObj )
{
if ( target == GL_TEXTURE_2D ) {
if ( target == GL_TEXTURE_2D ||
target == GL_TEXTURE_RECTANGLE_NV ) {
if ( tObj->DriverData == NULL ) {
mgaAllocTexObj( tObj );
}
@ -547,5 +550,7 @@ mgaDDInitTextureFuncs( GLcontext *ctx )
ctx->Driver.TexEnv = mgaDDTexEnv;
ctx->Driver.TexParameter = mgaDDTexParameter;
driInitTextureObjects( ctx, & mmesa->swapped, DRI_TEXMGR_DO_TEXTURE_2D );
driInitTextureObjects( ctx, & mmesa->swapped,
(DRI_TEXMGR_DO_TEXTURE_2D |
DRI_TEXMGR_DO_TEXTURE_RECT) );
}

2
src/mesa/drivers/dri/mga/mgatex.h
View file

@ -46,4 +46,6 @@ void mgaDestroyTexObj( mgaContextPtr mmesa, mgaTextureObjectPtr t );
void mgaDDInitTextureFuncs( GLcontext *ctx );
GLboolean mgaUpdateTextureEnvCombine( GLcontext *ctx, int unit );
#endif

14
src/mesa/drivers/dri/mga/mgatris.c
View file

@ -676,8 +676,7 @@ static void mgaFastRenderClippedPoly( GLcontext *ctx, const GLuint *elts,
#define POINT_FALLBACK (DD_POINT_SMOOTH)
#define LINE_FALLBACK (DD_LINE_SMOOTH | DD_LINE_STIPPLE)
#define TRI_FALLBACK (DD_TRI_SMOOTH | DD_TRI_UNFILLED)
#define ANY_FALLBACK_FLAGS (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK| \
DD_TRI_STIPPLE)
#define ANY_FALLBACK_FLAGS (POINT_FALLBACK|LINE_FALLBACK|TRI_FALLBACK)
#define ANY_RASTER_FLAGS (DD_FLATSHADE|DD_TRI_LIGHT_TWOSIDE|DD_TRI_OFFSET| \
DD_TRI_UNFILLED)
@ -688,7 +687,7 @@ void mgaChooseRenderState(GLcontext *ctx)
GLuint flags = ctx->_TriangleCaps;
GLuint index = 0;
if (flags & (ANY_FALLBACK_FLAGS|ANY_RASTER_FLAGS)) {
if (flags & (ANY_FALLBACK_FLAGS|ANY_RASTER_FLAGS|DD_TRI_STIPPLE)) {
if (flags & ANY_RASTER_FLAGS) {
if (flags & DD_TRI_LIGHT_TWOSIDE) index |= MGA_TWOSIDE_BIT;
if (flags & DD_TRI_OFFSET) index |= MGA_OFFSET_BIT;
@ -713,9 +712,11 @@ void mgaChooseRenderState(GLcontext *ctx)
if (flags & TRI_FALLBACK)
mmesa->draw_tri = mga_fallback_tri;
if ((flags & DD_TRI_STIPPLE) && !mmesa->haveHwStipple)
mmesa->draw_tri = mga_fallback_tri;
index |= MGA_FALLBACK_BIT;
}
if ((flags & DD_TRI_STIPPLE) && !mmesa->haveHwStipple) {
mmesa->draw_tri = mga_fallback_tri;
index |= MGA_FALLBACK_BIT;
}
}
@ -782,10 +783,9 @@ void mgaRasterPrimitive( GLcontext *ctx, GLenum prim, GLuint hwprim )
if (ctx->Polygon.StippleFlag && mmesa->haveHwStipple)
{
mmesa->dirty |= MGA_UPLOAD_CONTEXT;
mmesa->setup.dwgctl &= ~(0xf<<20);
if (mmesa->raster_primitive == GL_TRIANGLES)
mmesa->setup.dwgctl |= mmesa->poly_stipple;
else
mmesa->setup.dwgctl &= ~(0xf<<20);
}
}

7
src/mesa/drivers/dri/mga/mgavb.c
View file

@ -24,7 +24,7 @@
* Authors:
* Keith Whitwell <keith@tungstengraphics.com>
*/
/* $XFree86: xc/lib/GL/mesa/src/drv/mga/mgavb.c,v 1.14 2002/10/30 12:51:36 alanh Exp $ */
/* $XFree86: xc/lib/GL/mesa/src/drv/mga/mgavb.c,v 1.15 2003/03/26 20:43:49 tsi Exp $ */
#include "mgacontext.h"
#include "mgavb.h"
@ -340,6 +340,9 @@ void mgaCheckTexSizes( GLcontext *ctx )
tnl->Driver.Render.Interp = setup_tab[mmesa->SetupIndex].interp;
tnl->Driver.Render.CopyPV = setup_tab[mmesa->SetupIndex].copy_pv;
}
if (mmesa->Fallback) {
tnl->Driver.Render.Start(ctx);
}
}
}
@ -456,7 +459,7 @@ void mgaInitVB( GLcontext *ctx )
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
GLuint size = TNL_CONTEXT(ctx)->vb.Size;
mmesa->verts = ALIGN_MALLOC(size * sizeof(mgaVertex), 32);
mmesa->verts = (GLubyte *)ALIGN_MALLOC(size * sizeof(mgaVertex), 32);
{
static int firsttime = 1;

5
src/mesa/drivers/dri/r128/Makefile.X11
View file

@ -1,4 +1,4 @@
# $Id: Makefile.X11,v 1.2 2003/10/20 02:17:33 jonsmirl Exp $
# $Id: Makefile.X11,v 1.3 2003/10/21 06:05:43 jonsmirl Exp $
# Mesa 3-D graphics library
# Version: 5.0
@ -39,7 +39,8 @@ DRIVER_SOURCES = \
../common/mm.c \
../common/utils.c \
../common/texmem.c \
../common/vblank.c
../common/vblank.c \
../common/xmlconfig.c
INCLUDES = $(MINIGLX_INCLUDES) \
$(SHARED_INCLUDES)

37
src/mesa/drivers/dri/r128/r128_context.c
View file

@ -60,6 +60,27 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "utils.h"
#include "texmem.h"
/* R128 configuration
*/
#include "xmlpool.h"
const char __driConfigOptions[] =
DRI_CONF_BEGIN
#if ENABLE_PERF_BOXES
DRI_CONF_SECTION_DEBUG
DRI_CONF_PERFORMANCE_BOXES(false)
DRI_CONF_SECTION_END
#endif
DRI_CONF_SECTION_PERFORMANCE
DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_DEF_INTERVAL_0)
DRI_CONF_SECTION_END
DRI_CONF_END;
#if ENABLE_PERF_BOXES
const GLuint __driNConfigOptions = 2;
#else
const GLuint __driNConfigOptions = 1;
#endif
#ifndef R128_DEBUG
int R128_DEBUG = 0;
#endif
@ -127,6 +148,10 @@ GLboolean r128CreateContext( const __GLcontextModes *glVisual,
r128scrn = rmesa->r128Screen = (r128ScreenPtr)(sPriv->private);
/* Parse configuration files */
driParseConfigFiles (&rmesa->optionCache, &r128scrn->optionCache,
r128scrn->driScreen->myNum, "r128");
rmesa->sarea = (R128SAREAPrivPtr)((char *)sPriv->pSAREA +
r128scrn->sarea_priv_offset);
@ -191,7 +216,7 @@ GLboolean r128CreateContext( const __GLcontextModes *glVisual,
ctx->Const.LineWidthGranularity = 1.0;
#if ENABLE_PERF_BOXES
rmesa->boxes = (getenv( "LIBGL_PERFORMANCE_BOXES" ) != NULL);
rmesa->boxes = driQueryOptionb(&rmesa->optionCache, "performance_boxes");
#endif
/* Initialize the software rasterizer and helper modules.
@ -224,10 +249,8 @@ GLboolean r128CreateContext( const __GLcontextModes *glVisual,
r128DDInitTextureFuncs( ctx );
r128DDInitState( rmesa );
rmesa->do_irqs = (rmesa->r128Screen->irq && !getenv("R128_NO_IRQS"));
rmesa->vblank_flags = (rmesa->do_irqs)
? driGetDefaultVBlankFlags() : VBLANK_FLAG_NO_IRQ;
rmesa->vblank_flags = (rmesa->r128Screen->irq != 0)
? driGetDefaultVBlankFlags(&rmesa->optionCache) : VBLANK_FLAG_NO_IRQ;
driContextPriv->driverPrivate = (void *)rmesa;
@ -277,6 +300,9 @@ void r128DestroyContext( __DRIcontextPrivate *driContextPriv )
}
}
/* free the option cache */
driDestroyOptionCache (&rmesa->optionCache);
FREE( rmesa );
}
@ -305,6 +331,7 @@ r128MakeCurrent( __DRIcontextPrivate *driContextPriv,
newR128Ctx->dirty = R128_UPLOAD_ALL;
}
driDrawableInitVBlank( driDrawPriv, newR128Ctx->vblank_flags );
newR128Ctx->driDrawable = driDrawPriv;
_mesa_make_current2( newR128Ctx->glCtx,

8
src/mesa/drivers/dri/r128/r128_context.h
View file

@ -178,10 +178,6 @@ struct r128_context {
*/
GLuint doPageFlip;
/* Busy waiting
*/
GLuint do_irqs;
/* Drawable, cliprect and scissor information
*/
GLint drawOffset, drawPitch;
@ -222,6 +218,10 @@ struct r128_context {
*/
GLuint vbl_seq;
GLuint vblank_flags;
/* Configuration cache
*/
driOptionCache optionCache;
};
#define R128_CONTEXT(ctx) ((r128ContextPtr)(ctx->DriverCtx))

35
src/mesa/drivers/dri/r128/r128_screen.c
View file

@ -1,4 +1,4 @@
/* $XFree86: xc/lib/GL/mesa/src/drv/r128/r128_screen.c,v 1.8 2002/12/16 16:18:53 dawes Exp $ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r128/r128_screen.c,v 1.9 2003/03/26 20:43:49 tsi Exp $ */
/**************************************************************************
Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc.,
@ -55,7 +55,6 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#define PCI_CHIP_RAGE128LE 0x4C45
#define PCI_CHIP_RAGE128LF 0x4C46
#define PCI_CHIP_RAGE128PD 0x5044
#define PCI_CHIP_RAGE128PF 0x5046
#define PCI_CHIP_RAGE128PR 0x5052
#define PCI_CHIP_RAGE128RE 0x5245
@ -80,6 +79,9 @@ r128CreateScreen( __DRIscreenPrivate *sPriv )
r128Screen = (r128ScreenPtr) CALLOC( sizeof(*r128Screen) );
if ( !r128Screen ) return NULL;
/* parse information in __driConfigOptions */
driParseOptionInfo (&r128Screen->optionCache);
/* This is first since which regions we map depends on whether or
* not we are using a PCI card.
*/
@ -140,7 +142,6 @@ r128CreateScreen( __DRIscreenPrivate *sPriv )
case PCI_CHIP_RAGE128RL:
r128Screen->chipset = R128_CARD_TYPE_R128;
break;
case PCI_CHIP_RAGE128PD:
case PCI_CHIP_RAGE128PF:
r128Screen->chipset = R128_CARD_TYPE_R128_PRO;
break;
@ -183,7 +184,23 @@ r128CreateScreen( __DRIscreenPrivate *sPriv )
}
r128Screen->driScreen = sPriv;
#ifndef _SOLO
if ( driCompareGLXAPIVersion( 20030813 ) >= 0 ) {
PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
(PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
void * const psc = sPriv->psc->screenConfigs;
if ( glx_enable_extension != NULL ) {
if ( r128Screen->irq != 0 ) {
(*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
(*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
(*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
}
(*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
}
}
#endif
return r128Screen;
}
@ -204,6 +221,9 @@ r128DestroyScreen( __DRIscreenPrivate *sPriv )
drmUnmapBufs( r128Screen->buffers );
drmUnmap( (drmAddress)r128Screen->mmio.map, r128Screen->mmio.size );
/* free all option information */
driDestroyOptionInfo (&r128Screen->optionCache);
FREE( r128Screen );
sPriv->private = NULL;
}
@ -290,10 +310,13 @@ r128InitDriver( __DRIscreenPrivate *sPriv )
return GL_TRUE;
}
#ifndef _SOLO
/* This function is called by libGL.so as soon as libGL.so is loaded.
/**
* This function is called by libGL.so as soon as libGL.so is loaded.
* This is where we register new extension functions with the dispatcher.
*
* \todo This interface has been deprecated, so we should probably remove
* this function before the next XFree86 release.
*/
void __driRegisterExtensions( void )
{
@ -301,7 +324,7 @@ void __driRegisterExtensions( void )
if ( driCompareGLXAPIVersion( 20030317 ) >= 0 ) {
glx_enable_extension = (PFNGLXENABLEEXTENSIONPROC)
glXGetProcAddress( "__glXEnableExtension" );
glXGetProcAddress( (const GLubyte *) "__glXEnableExtension" );
if ( glx_enable_extension != NULL ) {
glx_enable_extension( "GLX_SGI_swap_control", GL_FALSE );

4
src/mesa/drivers/dri/r128/r128_screen.h
View file

@ -39,6 +39,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifdef GLX_DIRECT_RENDERING
#include "r128_sarea.h"
#include "xmlconfig.h"
typedef struct {
drmHandle handle; /* Handle to the DRM region */
@ -77,6 +78,9 @@ typedef struct {
__DRIscreenPrivate *driScreen;
unsigned int sarea_priv_offset;
/* Configuration cache with default values for all contexts */
driOptionCache optionCache;
} r128ScreenRec, *r128ScreenPtr;

2
src/mesa/drivers/dri/r128/r128_state.c
View file

@ -706,7 +706,7 @@ static void r128DDDrawBuffer( GLcontext *ctx, GLenum mode )
break;
}
/* We want to update the s/w rast state too so that r200SetBuffer()
/* We want to update the s/w rast state too so that r128DDSetBuffer()
* gets called.
*/
_swrast_DrawBuffer(ctx, mode);

2
src/mesa/drivers/dri/r128/r128_texmem.c
View file

@ -1,4 +1,4 @@
/* $XFree86: xc/lib/GL/mesa/src/drv/r128/r128_tex.c,v 1.7 2001/01/08 01:07:21 martin Exp $ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r128/r128_texmem.c,v 1.1 2002/02/22 21:44:58 dawes Exp $ */
/**************************************************************************
Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc.,

16
src/mesa/drivers/dri/r128/r128_texstate.c
View file

@ -1,4 +1,4 @@
/* $XFree86: xc/lib/GL/mesa/src/drv/r128/r128_tex.c,v 1.7 2001/01/08 01:07:21 martin Exp $ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r128/r128_texstate.c,v 1.1 2002/02/22 21:44:58 dawes Exp $ */
/**************************************************************************
Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc.,
@ -90,17 +90,11 @@ static void r128SetTexImages( r128ContextPtr rmesa,
};
/* Compute which mipmap levels we really want to send to the hardware.
* This depends on the base image size, GL_TEXTURE_MIN_LOD,
* GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL.
* Yes, this looks overly complicated, but it's all needed.
*/
firstLevel = tObj->BaseLevel + (GLint) (tObj->MinLod + 0.5);
firstLevel = MAX2(firstLevel, tObj->BaseLevel);
lastLevel = tObj->BaseLevel + (GLint) (tObj->MaxLod + 0.5);
lastLevel = MAX2(lastLevel, tObj->BaseLevel);
lastLevel = MIN2(lastLevel, tObj->BaseLevel + baseImage->MaxLog2);
lastLevel = MIN2(lastLevel, tObj->MaxLevel);
lastLevel = MAX2(firstLevel, lastLevel); /* need at least one level */
driCalculateTextureFirstLastLevel( (driTextureObject *) t );
firstLevel = t->base.firstLevel;
lastLevel = t->base.lastLevel;
log2Pitch = tObj->Image[firstLevel]->WidthLog2;
log2Height = tObj->Image[firstLevel]->HeightLog2;

7
src/mesa/drivers/dri/r128/r128_vb.c
View file

@ -1,4 +1,4 @@
/* $XFree86: xc/lib/GL/mesa/src/drv/r128/r128_vb.c,v 1.15 2002/10/30 12:51:43 alanh Exp $ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r128/r128_vb.c,v 1.16 2003/03/26 20:43:49 tsi Exp $ */
/**************************************************************************
Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and
@ -361,6 +361,9 @@ void r128CheckTexSizes( GLcontext *ctx )
tnl->Driver.Render.Interp = setup_tab[rmesa->SetupIndex].interp;
tnl->Driver.Render.CopyPV = setup_tab[rmesa->SetupIndex].copy_pv;
}
if (rmesa->Fallback) {
tnl->Driver.Render.Start(ctx);
}
}
}
@ -489,7 +492,7 @@ void r128InitVB( GLcontext *ctx )
r128ContextPtr rmesa = R128_CONTEXT(ctx);
GLuint size = TNL_CONTEXT(ctx)->vb.Size;
rmesa->verts = ALIGN_MALLOC(size * 4 * 16, 32);
rmesa->verts = (GLubyte *)ALIGN_MALLOC(size * 4 * 16, 32);
{
static int firsttime = 1;

3
src/mesa/drivers/dri/r200/Makefile.X11
View file

@ -1,4 +1,4 @@
# $Id: Makefile.X11,v 1.5 2003/10/20 02:17:33 jonsmirl Exp $
# $Id: Makefile.X11,v 1.6 2003/10/21 06:05:46 jonsmirl Exp $
# Mesa 3-D graphics library
# Version: 5.0
@ -33,6 +33,7 @@ DRIVER_SOURCES = r200_context.c \
../common/utils.c \
../common/texmem.c \
../common/vblank.c \
../common/xmlconfig.c \
r200_cmdbuf.c \
r200_pixel.c \
r200_tex.c \

2
src/mesa/drivers/dri/r200/r200_cmdbuf.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_cmdbuf.c,v 1.1 2002/10/30 12:51:51 alanh Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.

82
src/mesa/drivers/dri/r200/r200_context.c
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_context.c,v 1.3 2003/05/06 23:52:08 daenzer Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the
@ -69,8 +68,27 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
int R200_DEBUG = (0);
#endif
/* R200 configuration
*/
#include "xmlpool.h"
const char __driConfigOptions[] =
DRI_CONF_BEGIN
DRI_CONF_SECTION_PERFORMANCE
DRI_CONF_TCL_MODE(DRI_CONF_TCL_CODEGEN)
DRI_CONF_FTHROTTLE_MODE(DRI_CONF_FTHROTTLE_IRQS)
DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_DEF_INTERVAL_0)
DRI_CONF_SECTION_END
DRI_CONF_SECTION_QUALITY
DRI_CONF_PREFERRED_BPT(0,"0,16,32")
DRI_CONF_SECTION_END
DRI_CONF_SECTION_DEBUG
DRI_CONF_NO_RAST(false)
DRI_CONF_SECTION_END
DRI_CONF_END;
const GLuint __driNConfigOptions = 5;
/* Return the width and height of the given buffer.
*/
static void r200GetBufferSize( GLframebuffer *buffer,
@ -224,7 +242,7 @@ static const struct dri_debug_control debug_control[] =
static int
get_ust_nop( int64_t * ust )
get_ust_nop( uint64_t * ust )
{
*ust = 1;
return 0;
@ -242,6 +260,7 @@ GLboolean r200CreateContext( const __GLcontextModes *glVisual,
r200ContextPtr rmesa;
GLcontext *ctx, *shareCtx;
int i;
int tcl_mode, fthrottle_mode, preferred_bpt;
assert(glVisual);
assert(driContextPriv);
@ -273,6 +292,9 @@ GLboolean r200CreateContext( const __GLcontextModes *glVisual,
rmesa->dri.fd = sPriv->fd;
rmesa->dri.drmMinor = sPriv->drmMinor;
/* Parse configuration files */
driParseConfigFiles (&rmesa->optionCache, &screen->optionCache,
screen->driScreen->myNum, "r200");
rmesa->r200Screen = screen;
rmesa->sarea = (RADEONSAREAPrivPtr)((GLubyte *)sPriv->pSAREA +
screen->sarea_priv_offset);
@ -295,6 +317,9 @@ GLboolean r200CreateContext( const __GLcontextModes *glVisual,
sizeof( r200TexObj ),
(destroy_texture_object_t *) r200DestroyTexObj );
}
preferred_bpt = driQueryOptioni (&rmesa->optionCache, "preferred_bpt");
rmesa->default32BitTextures =
( ( preferred_bpt == 0 && screen->cpp == 4 ) || preferred_bpt == 32 );
rmesa->swtcl.RenderIndex = ~0;
rmesa->lost_context = 1;
@ -382,36 +407,38 @@ GLboolean r200CreateContext( const __GLcontextModes *glVisual,
r200InitState( rmesa );
r200InitSwtcl( ctx );
fthrottle_mode = driQueryOptioni(&rmesa->optionCache, "fthrottle_mode");
rmesa->iw.irq_seq = -1;
rmesa->irqsEmitted = 0;
rmesa->do_irqs = (rmesa->dri.drmMinor >= 6 &&
!getenv("R200_NO_IRQS") &&
fthrottle_mode == DRI_CONF_FTHROTTLE_IRQS &&
rmesa->r200Screen->irq);
rmesa->do_usleeps = (fthrottle_mode == DRI_CONF_FTHROTTLE_USLEEPS);
if (!rmesa->do_irqs)
fprintf(stderr,
"IRQ's not enabled, falling back to busy waits: %d %d %d\n",
"IRQ's not enabled, falling back to %s: %d %d %d\n",
rmesa->do_usleeps ? "usleeps" : "busy waits",
rmesa->dri.drmMinor,
!!getenv("R200_NO_IRQS"),
fthrottle_mode,
rmesa->r200Screen->irq);
rmesa->vblank_flags = (rmesa->r200Screen->irq != 0)
? driGetDefaultVBlankFlags(&rmesa->optionCache) : VBLANK_FLAG_NO_IRQ;
rmesa->do_usleeps = !getenv("R200_NO_USLEEPS");
rmesa->vblank_flags = (rmesa->do_irqs)
? driGetDefaultVBlankFlags() : VBLANK_FLAG_NO_IRQ;
rmesa->prefer_agp_client_texturing =
(getenv("R200_AGP_CLIENT_TEXTURES") != 0);
rmesa->prefer_gart_client_texturing =
(getenv("R200_GART_CLIENT_TEXTURES") != 0);
#ifndef _SOLO
rmesa->get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( "__glXGetUST" );
rmesa->get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( (const GLubyte *) "__glXGetUST" );
if ( rmesa->get_ust == NULL ) {
rmesa->get_ust = get_ust_nop;
}
(*rmesa->get_ust)( & rmesa->swap_ust );
#else
rmesa->get_ust = get_ust_nop;
#endif
(*rmesa->get_ust)( & rmesa->swap_ust );
#if DO_DEBUG
R200_DEBUG = driParseDebugString( getenv( "R200_DEBUG" ),
@ -420,17 +447,18 @@ GLboolean r200CreateContext( const __GLcontextModes *glVisual,
debug_control );
#endif
if (getenv("R200_NO_RAST")) {
tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
if (driQueryOptionb(&rmesa->optionCache, "no_rast")) {
fprintf(stderr, "disabling 3D acceleration\n");
FALLBACK(rmesa, R200_FALLBACK_DISABLE, 1);
}
else if (getenv("R200_NO_TCL")) {
else if (tcl_mode == DRI_CONF_TCL_SW) {
fprintf(stderr, "disabling TCL support\n");
TCL_FALLBACK(rmesa->glCtx, R200_TCL_FALLBACK_TCL_DISABLE, 1);
}
else {
if (!getenv("R200_NO_VTXFMT")) {
r200VtxfmtInit( ctx );
if (tcl_mode >= DRI_CONF_TCL_VTXFMT) {
r200VtxfmtInit( ctx, tcl_mode >= DRI_CONF_TCL_CODEGEN );
}
_tnl_need_dlist_norm_lengths( ctx, GL_FALSE );
}
@ -474,9 +502,11 @@ void r200DestroyContext( __DRIcontextPrivate *driContextPriv )
r200FlushCmdBuf( rmesa, __FUNCTION__ );
}
if (!rmesa->TclFallback & R200_TCL_FALLBACK_TCL_DISABLE)
if (!getenv("R200_NO_VTXFMT"))
if (!(rmesa->TclFallback & R200_TCL_FALLBACK_TCL_DISABLE)) {
int tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
if (tcl_mode >= DRI_CONF_TCL_VTXFMT)
r200VtxfmtDestroy( rmesa->glCtx );
}
/* free the Mesa context */
rmesa->glCtx->DriverCtx = NULL;
@ -502,6 +532,9 @@ void r200DestroyContext( __DRIcontextPrivate *driContextPriv )
}
}
/* free the option cache */
driDestroyOptionCache (&rmesa->optionCache);
FREE( rmesa );
}
}
@ -550,6 +583,7 @@ r200MakeCurrent( __DRIcontextPrivate *driContextPriv,
fprintf(stderr, "%s ctx %p\n", __FUNCTION__, newCtx->glCtx);
if ( newCtx->dri.drawable != driDrawPriv ) {
driDrawableInitVBlank( driDrawPriv, newCtx->vblank_flags );
newCtx->dri.drawable = driDrawPriv;
r200UpdateWindow( newCtx->glCtx );
r200UpdateViewportOffset( newCtx->glCtx );

14
src/mesa/drivers/dri/r200/r200_context.h
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_context.h,v 1.2 2002/12/16 16:18:54 dawes Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the
@ -532,7 +531,7 @@ struct r200_dma_buffer {
drmBufPtr buf;
};
#define GET_START(rvb) (rmesa->r200Screen->agp_buffer_offset + \
#define GET_START(rvb) (rmesa->r200Screen->gart_buffer_offset + \
(rvb)->address - rmesa->dma.buf0_address + \
(rvb)->start)
@ -779,6 +778,7 @@ struct r200_context {
unsigned nr_heaps;
driTexHeap * texture_heaps[ R200_NR_TEX_HEAPS ];
driTextureObject swapped;
GLboolean default32BitTextures;
/* Rasterization and vertex state:
@ -812,7 +812,7 @@ struct r200_context {
/* Clientdata textures;
*/
GLuint prefer_agp_client_texturing;
GLuint prefer_gart_client_texturing;
/* Drawable, cliprect and scissor information
*/
@ -863,6 +863,10 @@ struct r200_context {
/* Mirrors of some DRI state
*/
struct r200_dri_mirror dri;
/* Configuration cache
*/
driOptionCache optionCache;
};
#define R200_CONTEXT(ctx) ((r200ContextPtr)(ctx->DriverCtx))

58
src/mesa/drivers/dri/r200/r200_ioctl.c
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_ioctl.c,v 1.4 2002/12/17 00:32:56 dawes Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the
@ -773,7 +772,7 @@ void r200Finish( GLcontext *ctx )
}
/* This version of AllocateMemoryNV allocates only agp memory, and
/* This version of AllocateMemoryMESA allocates only GART memory, and
* only does so after the point at which the driver has been
* initialized.
*
@ -782,8 +781,9 @@ void r200Finish( GLcontext *ctx )
* the kernel data structures, and the current context to get the
* device fd.
*/
void *r200AllocateMemoryNV(GLsizei size, GLfloat readfreq,
GLfloat writefreq, GLfloat priority)
void *r200AllocateMemoryMESA(GLsizei size,
GLfloat readfreq, GLfloat writefreq,
GLfloat priority)
{
GET_CURRENT_CONTEXT(ctx);
r200ContextPtr rmesa;
@ -795,7 +795,7 @@ void *r200AllocateMemoryNV(GLsizei size, GLfloat readfreq,
fprintf(stderr, "%s sz %d %f/%f/%f\n", __FUNCTION__, size, readfreq,
writefreq, priority);
if (!ctx || !(rmesa = R200_CONTEXT(ctx)) || rmesa->r200Screen->IsPCI )
if (!ctx || !(rmesa = R200_CONTEXT(ctx)) || !rmesa->r200Screen->gartTextures.map)
return NULL;
if (getenv("R200_NO_ALLOC"))
@ -804,7 +804,7 @@ void *r200AllocateMemoryNV(GLsizei size, GLfloat readfreq,
if (rmesa->dri.drmMinor < 6)
return NULL;
alloc.region = RADEON_MEM_REGION_AGP;
alloc.region = RADEON_MEM_REGION_GART;
alloc.alignment = 0;
alloc.size = size;
alloc.region_offset = &region_offset;
@ -819,14 +819,14 @@ void *r200AllocateMemoryNV(GLsizei size, GLfloat readfreq,
}
{
char *region_start = (char *)rmesa->r200Screen->agpTextures.map;
char *region_start = (char *)rmesa->r200Screen->gartTextures.map;
return (void *)(region_start + region_offset);
}
}
/* Called via glXFreeMemoryNV() */
void r200FreeMemoryNV(GLvoid *pointer)
/* Called via glXFreeMemoryMESA() */
void r200FreeMemoryMESA(GLvoid *pointer)
{
GET_CURRENT_CONTEXT(ctx);
r200ContextPtr rmesa;
@ -837,7 +837,7 @@ void r200FreeMemoryNV(GLvoid *pointer)
if (R200_DEBUG & DEBUG_IOCTL)
fprintf(stderr, "%s %p\n", __FUNCTION__, pointer);
if (!ctx || !(rmesa = R200_CONTEXT(ctx)) || rmesa->r200Screen->IsPCI ) {
if (!ctx || !(rmesa = R200_CONTEXT(ctx)) || !rmesa->r200Screen->gartTextures.map) {
fprintf(stderr, "%s: no context\n", __FUNCTION__);
return;
}
@ -845,16 +845,16 @@ void r200FreeMemoryNV(GLvoid *pointer)
if (rmesa->dri.drmMinor < 6)
return;
region_offset = (char *)pointer - (char *)rmesa->r200Screen->agpTextures.map;
region_offset = (char *)pointer - (char *)rmesa->r200Screen->gartTextures.map;
if (region_offset < 0 ||
region_offset > rmesa->r200Screen->agpTextures.size) {
region_offset > rmesa->r200Screen->gartTextures.size) {
fprintf(stderr, "offset %d outside range 0..%d\n", region_offset,
rmesa->r200Screen->agpTextures.size);
rmesa->r200Screen->gartTextures.size);
return;
}
memfree.region = RADEON_MEM_REGION_AGP;
memfree.region = RADEON_MEM_REGION_GART;
memfree.region_offset = region_offset;
ret = drmCommandWrite( rmesa->r200Screen->driScreen->fd,
@ -865,8 +865,8 @@ void r200FreeMemoryNV(GLvoid *pointer)
fprintf(stderr, "%s: DRM_RADEON_FREE ret %d\n", __FUNCTION__, ret);
}
/* Called via glXGetAGPOffsetMESA() */
GLuint r200GetAGPOffset(const GLvoid *pointer)
/* Called via glXGetMemoryOffsetMESA() */
GLuint r200GetMemoryOffsetMESA(const GLvoid *pointer)
{
GET_CURRENT_CONTEXT(ctx);
r200ContextPtr rmesa;
@ -877,41 +877,41 @@ GLuint r200GetAGPOffset(const GLvoid *pointer)
return ~0;
}
if (!r200IsAgpMemory( rmesa, pointer, 0 ))
if (!r200IsGartMemory( rmesa, pointer, 0 ))
return ~0;
if (rmesa->dri.drmMinor < 6)
return ~0;
card_offset = r200AgpOffsetFromVirtual( rmesa, pointer );
card_offset = r200GartOffsetFromVirtual( rmesa, pointer );
return card_offset - rmesa->r200Screen->agp_base;
return card_offset - rmesa->r200Screen->gart_base;
}
GLboolean r200IsAgpMemory( r200ContextPtr rmesa, const GLvoid *pointer,
GLboolean r200IsGartMemory( r200ContextPtr rmesa, const GLvoid *pointer,
GLint size )
{
int offset = (char *)pointer - (char *)rmesa->r200Screen->agpTextures.map;
int offset = (char *)pointer - (char *)rmesa->r200Screen->gartTextures.map;
int valid = (size >= 0 &&
offset >= 0 &&
offset + size < rmesa->r200Screen->agpTextures.size);
offset + size < rmesa->r200Screen->gartTextures.size);
if (R200_DEBUG & DEBUG_IOCTL)
fprintf(stderr, "r200IsAgpMemory( %p ) : %d\n", pointer, valid );
fprintf(stderr, "r200IsGartMemory( %p ) : %d\n", pointer, valid );
return valid;
}
GLuint r200AgpOffsetFromVirtual( r200ContextPtr rmesa, const GLvoid *pointer )
GLuint r200GartOffsetFromVirtual( r200ContextPtr rmesa, const GLvoid *pointer )
{
int offset = (char *)pointer - (char *)rmesa->r200Screen->agpTextures.map;
int offset = (char *)pointer - (char *)rmesa->r200Screen->gartTextures.map;
if (offset < 0 || offset > rmesa->r200Screen->agpTextures.size)
if (offset < 0 || offset > rmesa->r200Screen->gartTextures.size)
return ~0;
else
return rmesa->r200Screen->agp_texture_offset + offset;
return rmesa->r200Screen->gart_texture_offset + offset;
}

15
src/mesa/drivers/dri/r200/r200_ioctl.h
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_ioctl.h,v 1.1 2002/10/30 12:51:52 alanh Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the
@ -106,14 +105,14 @@ extern void r200WaitForIdleLocked( r200ContextPtr rmesa );
extern void r200WaitForVBlank( r200ContextPtr rmesa );
extern void r200InitIoctlFuncs( GLcontext *ctx );
extern void *r200AllocateMemoryNV( GLsizei size, GLfloat readfreq,
extern void *r200AllocateMemoryMESA( GLsizei size, GLfloat readfreq,
GLfloat writefreq, GLfloat priority );
extern void r200FreeMemoryNV( GLvoid *pointer );
extern GLuint r200GetAGPOffset( const GLvoid *pointer );
extern GLboolean r200IsAgpMemory( r200ContextPtr rmesa, const GLvoid *pointer,
extern void r200FreeMemoryMESA( GLvoid *pointer );
extern GLuint r200GetMemoryOffsetMESA( const GLvoid *pointer );
extern GLboolean r200IsGartMemory( r200ContextPtr rmesa, const GLvoid *pointer,
GLint size );
extern GLuint r200AgpOffsetFromVirtual( r200ContextPtr rmesa,
extern GLuint r200GartOffsetFromVirtual( r200ContextPtr rmesa,
const GLvoid *pointer );
/* ================================================================

5
src/mesa/drivers/dri/r200/r200_lock.c
View file

@ -1,5 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_lock.c,v 1.1 2002/10/30 12:51:52 alanh Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the
@ -81,6 +81,7 @@ r200UpdatePageFlipping( r200ContextPtr rmesa )
void r200GetLock( r200ContextPtr rmesa, GLuint flags )
{
__DRIdrawablePrivate *dPriv = rmesa->dri.drawable;
__DRIscreenPrivate *sPriv = rmesa->dri.screen;
RADEONSAREAPrivPtr sarea = rmesa->sarea;
int i;

4
src/mesa/drivers/dri/r200/r200_lock.h
View file

@ -1,5 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_lock.h,v 1.1 2002/10/30 12:51:52 alanh Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the

5
src/mesa/drivers/dri/r200/r200_maos.h
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_maos.h,v 1.1 2002/10/30 12:51:52 alanh Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the

31
src/mesa/drivers/dri/r200/r200_maos_arrays.c
View file

@ -1,5 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_maos_arrays.c,v 1.3 2003/02/23 23:59:01 dawes Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the
@ -175,6 +175,28 @@ static void emit_ubyte_rgba( GLcontext *ctx,
}
static void emit_vec4( GLcontext *ctx,
struct r200_dma_region *rvb,
char *data,
int stride,
int count )
{
int i;
int *out = (int *)(rvb->address + rvb->start);
if (R200_DEBUG & DEBUG_VERTS)
fprintf(stderr, "%s count %d stride %d\n",
__FUNCTION__, count, stride);
if (stride == 4)
COPY_DWORDS( out, data, count );
else
for (i = 0; i < count; i++) {
out[0] = *(int *)data;
out++;
data += stride;
}
}
static void emit_vec8( GLcontext *ctx,
@ -285,6 +307,9 @@ static void emit_vector( GLcontext *ctx,
/* Emit the data
*/
switch (size) {
case 1:
emit_vec4( ctx, rvb, data, stride, count );
break;
case 2:
emit_vec8( ctx, rvb, data, stride, count );
break;
@ -304,7 +329,7 @@ static void emit_vector( GLcontext *ctx,
/* Emit any changed arrays to new agp memory, re-emit a packet to
/* Emit any changed arrays to new GART memory, re-emit a packet to
* update the arrays.
*/
void r200EmitArrays( GLcontext *ctx, GLuint inputs )

2
src/mesa/drivers/dri/r200/r200_maos_vbtmp.h
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_maos_vbtmp.h,v 1.2 2002/12/16 16:18:54 dawes Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.

5
src/mesa/drivers/dri/r200/r200_maos_verts.c
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_maos_verts.c,v 1.1 2002/10/30 12:51:52 alanh Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the

20
src/mesa/drivers/dri/r200/r200_pixel.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_pixel.c,v 1.2 2002/12/16 16:18:54 dawes Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
@ -160,12 +160,12 @@ r200TryReadPixels( GLcontext *ctx,
if (R200_DEBUG & DEBUG_PIXEL)
fprintf(stderr, "%s\n", __FUNCTION__);
/* Only accelerate reading to agp buffers.
/* Only accelerate reading to GART buffers.
*/
if ( !r200IsAgpMemory(rmesa, pixels,
if ( !r200IsGartMemory(rmesa, pixels,
pitch * height * rmesa->r200Screen->cpp ) ) {
if (R200_DEBUG & DEBUG_PIXEL)
fprintf(stderr, "%s: dest not agp\n", __FUNCTION__);
fprintf(stderr, "%s: dest not GART\n", __FUNCTION__);
return GL_FALSE;
}
@ -217,7 +217,7 @@ r200TryReadPixels( GLcontext *ctx,
int nbox = dPriv->numClipRects;
int src_offset = rmesa->state.color.drawOffset;
int src_pitch = rmesa->state.color.drawPitch * rmesa->r200Screen->cpp;
int dst_offset = r200AgpOffsetFromVirtual( rmesa, pixels);
int dst_offset = r200GartOffsetFromVirtual( rmesa, pixels );
int dst_pitch = pitch * rmesa->r200Screen->cpp;
XF86DRIClipRectRec *box = dPriv->pClipRects;
int i;
@ -297,7 +297,7 @@ static void do_draw_pix( GLcontext *ctx,
int i;
int blit_format;
int size;
int src_offset = r200AgpOffsetFromVirtual( rmesa, pixels);
int src_offset = r200GartOffsetFromVirtual( rmesa, pixels );
int src_pitch = pitch * rmesa->r200Screen->cpp;
if (R200_DEBUG & DEBUG_PIXEL)
@ -402,11 +402,11 @@ r200TryDrawPixels( GLcontext *ctx,
if (planemask != ~0)
return GL_FALSE; /* fix me -- should be possible */
/* Can't do conversions on agp reads/draws.
/* Can't do conversions on GART reads/draws.
*/
if ( !r200IsAgpMemory( rmesa, pixels, size ) ) {
if ( !r200IsGartMemory( rmesa, pixels, size ) ) {
if (R200_DEBUG & DEBUG_PIXEL)
fprintf(stderr, "%s: not agp memory\n", __FUNCTION__);
fprintf(stderr, "%s: not GART memory\n", __FUNCTION__);
return GL_FALSE;
}
@ -426,7 +426,7 @@ r200TryDrawPixels( GLcontext *ctx,
return GL_FALSE;
}
if ( r200IsAgpMemory(rmesa, pixels, size) )
if ( r200IsGartMemory(rmesa, pixels, size) )
{
do_draw_pix( ctx, x, y, width, height, pitch, pixels,
dest, planemask );

2
src/mesa/drivers/dri/r200/r200_pixel.h
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_pixel.h,v 1.1 2002/10/30 12:51:52 alanh Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.

8
src/mesa/drivers/dri/r200/r200_reg.h
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_reg.h,v 1.2 2002/12/16 16:18:54 dawes Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
@ -1434,11 +1434,5 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define R200_CP_CMD_BITBLT_MULTI 0xC0009B00
#define R200_CP_CMD_TRANS_BITBLT 0xC0009C00
#define R200_AGP_TEX_OFFSET 0x02000000
#endif

3
src/mesa/drivers/dri/r200/r200_sanity.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_sanity.c,v 1.1 2002/10/30 12:51:52 alanh Exp $ */
/**************************************************************************
Copyright 2002 ATI Technologies Inc., Ontario, Canada, and
@ -32,6 +32,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
* Keith Whitwell <keith@tungstengraphics.com>
*
*/
#include <errno.h>
#include "glheader.h"

144
src/mesa/drivers/dri/r200/r200_screen.c
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_screen.c,v 1.4 2003/05/08 09:25:35 herrb Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the
@ -43,14 +42,14 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "r200_screen.h"
#include "r200_context.h"
#include "r200_ioctl.h"
#include "radeon_macros.h"
#include "radeon_reg.h"
#include "utils.h"
#include "vblank.h"
#ifndef _SOLO
#include "glxextensions.h"
#endif
#if 1
/* Including xf86PciInfo.h introduces a bunch of errors...
*/
@ -108,6 +107,8 @@ r200CreateScreen( __DRIscreenPrivate *sPriv )
break;
}
/* parse information in __driConfigOptions */
driParseOptionInfo (&screen->optionCache);
/* This is first since which regions we map depends on whether or
* not we are using a PCI card.
@ -118,30 +119,26 @@ r200CreateScreen( __DRIscreenPrivate *sPriv )
int ret;
drmRadeonGetParam gp;
gp.param = RADEON_PARAM_AGP_BUFFER_OFFSET;
gp.value = &screen->agp_buffer_offset;
gp.param = RADEON_PARAM_GART_BUFFER_OFFSET;
gp.value = &screen->gart_buffer_offset;
ret = drmCommandWriteRead( sPriv->fd, DRM_RADEON_GETPARAM,
&gp, sizeof(gp));
if (ret) {
FREE( screen );
fprintf(stderr, "drmRadeonGetParam (RADEON_PARAM_AGP_BUFFER_OFFSET): %d\n", ret);
fprintf(stderr, "drmRadeonGetParam (RADEON_PARAM_GART_BUFFER_OFFSET): %d\n", ret);
return NULL;
}
screen->agp_texture_offset =
screen->agp_buffer_offset + 2*1024*1024;
if (sPriv->drmMinor >= 6) {
gp.param = RADEON_PARAM_AGP_BASE;
gp.value = &screen->agp_base;
gp.param = RADEON_PARAM_GART_BASE;
gp.value = &screen->gart_base;
ret = drmCommandWriteRead( sPriv->fd, DRM_RADEON_GETPARAM,
&gp, sizeof(gp));
if (ret) {
FREE( screen );
fprintf(stderr, "drmR200GetParam (RADEON_PARAM_AGP_BASE): %d\n", ret);
fprintf(stderr, "drmR200GetParam (RADEON_PARAM_GART_BASE): %d\n", ret);
return NULL;
}
@ -196,24 +193,28 @@ r200CreateScreen( __DRIscreenPrivate *sPriv )
return NULL;
}
if ( !screen->IsPCI ) {
screen->agpTextures.handle = dri_priv->agpTexHandle;
screen->agpTextures.size = dri_priv->agpTexMapSize;
if ( dri_priv->gartTexHandle && dri_priv->gartTexMapSize ) {
unsigned char *RADEONMMIO = screen->mmio.map;
screen->gartTextures.handle = dri_priv->gartTexHandle;
screen->gartTextures.size = dri_priv->gartTexMapSize;
if ( drmMap( sPriv->fd,
screen->agpTextures.handle,
screen->agpTextures.size,
(drmAddressPtr)&screen->agpTextures.map ) ) {
screen->gartTextures.handle,
screen->gartTextures.size,
(drmAddressPtr)&screen->gartTextures.map ) ) {
drmUnmapBufs( screen->buffers );
drmUnmap( screen->status.map, screen->status.size );
drmUnmap( screen->mmio.map, screen->mmio.size );
FREE( screen );
__driUtilMessage("%s: IsPCI failed\n", __FUNCTION__);
__driUtilMessage("%s: drmMAP failed for GART texture area\n", __FUNCTION__);
return NULL;
}
screen->gart_texture_offset = dri_priv->gartTexOffset + ( screen->IsPCI
? INREG( RADEON_AIC_LO_ADDR )
: ( ( INREG( RADEON_MC_AGP_LOCATION ) & 0x0ffffU ) << 16 ) );
}
screen->cpp = dri_priv->bpp / 8;
screen->AGPMode = dri_priv->AGPMode;
@ -229,22 +230,46 @@ r200CreateScreen( __DRIscreenPrivate *sPriv )
screen->logTexGranularity[RADEON_CARD_HEAP] =
dri_priv->log2TexGran;
if ( screen->IsPCI ) {
if ( !screen->gartTextures.map ) {
screen->numTexHeaps = RADEON_NR_TEX_HEAPS - 1;
screen->texOffset[RADEON_AGP_HEAP] = 0;
screen->texSize[RADEON_AGP_HEAP] = 0;
screen->logTexGranularity[RADEON_AGP_HEAP] = 0;
screen->texOffset[RADEON_GART_HEAP] = 0;
screen->texSize[RADEON_GART_HEAP] = 0;
screen->logTexGranularity[RADEON_GART_HEAP] = 0;
} else {
screen->numTexHeaps = RADEON_NR_TEX_HEAPS;
screen->texOffset[RADEON_AGP_HEAP] =
dri_priv->agpTexOffset + R200_AGP_TEX_OFFSET;
screen->texSize[RADEON_AGP_HEAP] = dri_priv->agpTexMapSize;
screen->logTexGranularity[RADEON_AGP_HEAP] =
dri_priv->log2AGPTexGran;
screen->texOffset[RADEON_GART_HEAP] = screen->gart_texture_offset;
screen->texSize[RADEON_GART_HEAP] = dri_priv->gartTexMapSize;
screen->logTexGranularity[RADEON_GART_HEAP] =
dri_priv->log2GARTTexGran;
}
screen->driScreen = sPriv;
screen->sarea_priv_offset = dri_priv->sarea_priv_offset;
#ifndef _SOLO
if ( driCompareGLXAPIVersion( 20030813 ) >= 0 ) {
PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
(PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
void * const psc = sPriv->psc->screenConfigs;
if ( glx_enable_extension != NULL ) {
if ( screen->irq != 0 ) {
(*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
(*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
(*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
}
(*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
if ( driCompareGLXAPIVersion( 20030818 ) >= 0 ) {
sPriv->psc->allocateMemory = r200AllocateMemoryMESA;
sPriv->psc->freeMemory = r200FreeMemoryMESA;
sPriv->psc->memoryOffset = r200GetMemoryOffsetMESA;
(*glx_enable_extension)( psc, "GLX_MESA_allocate_memory" );
}
}
}
#endif
return screen;
}
@ -258,14 +283,16 @@ r200DestroyScreen( __DRIscreenPrivate *sPriv )
if (!screen)
return;
if ( !screen->IsPCI ) {
drmUnmap( screen->agpTextures.map,
screen->agpTextures.size );
if ( screen->gartTextures.map ) {
drmUnmap( screen->gartTextures.map, screen->gartTextures.size );
}
drmUnmapBufs( screen->buffers );
drmUnmap( screen->status.map, screen->status.size );
drmUnmap( screen->mmio.map, screen->mmio.size );
/* free all option information */
driDestroyOptionInfo (&screen->optionCache);
FREE( screen );
sPriv->private = NULL;
}
@ -380,56 +407,31 @@ void *__driCreateScreen(struct DRIDriverRec *driver,
}
#endif
#ifndef _SOLO
/* This function is called by libGL.so to allow the driver to dynamically
/**
* This function is called by libGL.so to allow the driver to dynamically
* extend libGL. We can add new GLX functions and/or new GL functions.
* Note that _mesa_create_context() will probably add most of the newer
* OpenGL extension functions into the dispatcher.
*
* \todo This interface has been deprecated, so we should probably remove
* this function before the next XFree86 release.
*/
void
__driRegisterExtensions( void )
{
PFNGLXENABLEEXTENSIONPROC glx_enable_extension;
typedef void *(*registerFunc)(const char *funcName, void *funcAddr);
registerFunc regFunc;
if ( driCompareGLXAPIVersion( 20030317 ) >= 0 ) {
glx_enable_extension = (PFNGLXENABLEEXTENSIONPROC)
glXGetProcAddress( "__glXEnableExtension" );
glXGetProcAddress( (const GLubyte *) "__glXEnableExtension" );
if ( glx_enable_extension != NULL ) {
glx_enable_extension( "GLX_SGI_swap_control", GL_FALSE );
glx_enable_extension( "GLX_SGI_video_sync", GL_FALSE );
glx_enable_extension( "GLX_MESA_swap_control", GL_FALSE );
glx_enable_extension( "GLX_MESA_swap_frame_usage", GL_FALSE );
/* Get pointers to libGL's __glXRegisterGLXFunction
* and __glXRegisterGLXExtensionString, if they exist.
*/
regFunc = (registerFunc) glXGetProcAddress( "__glXRegisterGLXFunction" );
if (regFunc) {
/* register our GLX extensions with libGL */
void *p;
p = regFunc("glXAllocateMemoryNV", (void *) r200AllocateMemoryNV);
if (p)
; /* XXX already registered - what to do, wrap? */
p = regFunc("glXFreeMemoryNV", (void *) r200FreeMemoryNV);
if (p)
; /* XXX already registered - what to do, wrap? */
p = regFunc("glXGetAGPOffsetMESA", (void *) r200GetAGPOffset);
if (p)
; /* XXX already registered - what to do, wrap? */
glx_enable_extension( "GLX_NV_vertex_array_range", GL_TRUE );
glx_enable_extension( "GLX_MESA_agp_offset", GL_TRUE );
}
(*glx_enable_extension)( "GLX_SGI_swap_control", GL_FALSE );
(*glx_enable_extension)( "GLX_SGI_video_sync", GL_FALSE );
(*glx_enable_extension)( "GLX_MESA_swap_control", GL_FALSE );
(*glx_enable_extension)( "GLX_MESA_swap_frame_usage", GL_FALSE );
}
}
}

17
src/mesa/drivers/dri/r200/r200_screen.h
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_screen.h,v 1.1 2002/10/30 12:51:52 alanh Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the
@ -43,6 +42,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "xf86drm.h"
#include "radeon_common.h"
#include "radeon_sarea.h"
#include "xmlconfig.h"
typedef struct {
drmHandle handle; /* Handle to the DRM region */
@ -80,7 +80,7 @@ typedef struct {
r200RegionRec mmio;
r200RegionRec status;
r200RegionRec agpTextures;
r200RegionRec gartTextures;
drmBufMapPtr buffers;
@ -88,11 +88,14 @@ typedef struct {
__DRIscreenPrivate *driScreen;
unsigned int sarea_priv_offset;
unsigned int agp_buffer_offset; /* offset in card memory space */
unsigned int agp_texture_offset; /* offset in card memory space */
unsigned int agp_base;
unsigned int gart_buffer_offset; /* offset in card memory space */
unsigned int gart_texture_offset; /* offset in card memory space */
unsigned int gart_base;
GLboolean drmSupportsCubeMaps; /* need radeon kernel module >=1.7 */
/* Configuration cache with default values for all contexts */
driOptionCache optionCache;
} r200ScreenRec, *r200ScreenPtr;
#endif

5
src/mesa/drivers/dri/r200/r200_span.c
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_span.c,v 1.1 2002/10/30 12:51:52 alanh Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the

5
src/mesa/drivers/dri/r200/r200_span.h
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_span.h,v 1.1 2002/10/30 12:51:52 alanh Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the

5
src/mesa/drivers/dri/r200/r200_state.h
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_state.h,v 1.2 2002/11/05 17:46:08 tsi Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the

24
src/mesa/drivers/dri/r200/r200_state_init.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_state_init.c,v 1.4 2003/02/22 06:21:11 dawes Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
@ -130,28 +130,15 @@ static GLboolean check_##NM( GLcontext *ctx, int idx ) \
CHECK( always, GL_TRUE )
CHECK( never, GL_FALSE )
CHECK( tex_any, ctx->Texture._EnabledUnits )
CHECK( tex, ctx->Texture.Unit[idx]._ReallyEnabled )
CHECK( fog, ctx->Fog.Enabled )
TCL_CHECK( tcl, GL_TRUE )
TCL_CHECK( tcl_tex_any, ctx->Texture._EnabledUnits )
TCL_CHECK( tcl_tex, ctx->Texture.Unit[idx]._ReallyEnabled )
TCL_CHECK( tcl_lighting, ctx->Light.Enabled )
TCL_CHECK( tcl_eyespace_or_lighting, ctx->_NeedEyeCoords || ctx->Light.Enabled )
TCL_CHECK( tcl_light, ctx->Light.Enabled && ctx->Light.Light[idx].Enabled )
TCL_CHECK( tcl_ucp, (ctx->Transform.ClipPlanesEnabled & (1 << idx)) )
/* TCL_CHECK( tcl_eyespace_or_fog, ctx->_NeedEyeCoords || ctx->Fog.Enabled ) */
static GLboolean check_tcl_eyespace_or_fog( GLcontext *ctx, int idx )
{
r200ContextPtr rmesa = R200_CONTEXT(ctx);
int res;
(void) idx;
res = !rmesa->TclFallback && (ctx->_NeedEyeCoords || ctx->Fog.Enabled);
fprintf(stderr, "%s: %d\n", __FUNCTION__, res);
return res;
}
/* Initialize the context's hardware state.
@ -244,8 +231,15 @@ void r200InitState( r200ContextPtr rmesa )
ALLOC_STATE( tf, tex_any, TF_STATE_SIZE, "TF/tfactor", 0 );
ALLOC_STATE( tex[0], tex_any, TEX_STATE_SIZE, "TEX/tex-0", 0 );
ALLOC_STATE( tex[1], tex_any, TEX_STATE_SIZE, "TEX/tex-1", 1 );
if (rmesa->r200Screen->drmSupportsCubeMaps) {
ALLOC_STATE( cube[0], tex_any, CUBE_STATE_SIZE, "CUBE/tex-0", 0 );
ALLOC_STATE( cube[1], tex_any, CUBE_STATE_SIZE, "CUBE/tex-1", 1 );
}
else {
ALLOC_STATE( cube[0], never, CUBE_STATE_SIZE, "CUBE/tex-0", 0 );
ALLOC_STATE( cube[1], never, CUBE_STATE_SIZE, "CUBE/tex-1", 1 );
}
ALLOC_STATE( tcl, tcl, TCL_STATE_SIZE, "TCL/tcl", 0 );
ALLOC_STATE( msl, tcl, MSL_STATE_SIZE, "MSL/matrix-select", 0 );

11
src/mesa/drivers/dri/r200/r200_swtcl.c
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_swtcl.c,v 1.5 2003/05/06 23:52:08 daenzer Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the
@ -397,7 +396,7 @@ static void flush_last_swtcl_prim( r200ContextPtr rmesa )
if (rmesa->dma.current.buf) {
struct r200_dma_region *current = &rmesa->dma.current;
GLuint current_offset = (rmesa->r200Screen->agp_buffer_offset +
GLuint current_offset = (rmesa->r200Screen->gart_buffer_offset +
current->buf->buf->idx * RADEON_BUFFER_SIZE +
current->start);
@ -446,7 +445,7 @@ static __inline void *r200AllocDmaLowVerts( r200ContextPtr rmesa,
{
char *head = rmesa->dma.current.address + rmesa->dma.current.ptr;
GLubyte *head = (GLubyte *) (rmesa->dma.current.address + rmesa->dma.current.ptr);
rmesa->dma.current.ptr += bytes;
rmesa->swtcl.numverts += nverts;
return head;
@ -590,7 +589,7 @@ do { \
\
r200EmitVertexAOS( rmesa, \
rmesa->swtcl.vertex_size, \
(rmesa->r200Screen->agp_buffer_offset + \
(rmesa->r200Screen->gart_buffer_offset + \
rmesa->swtcl.indexed_verts.buf->buf->idx * \
RADEON_BUFFER_SIZE + \
rmesa->swtcl.indexed_verts.start)); \

2
src/mesa/drivers/dri/r200/r200_swtcl.h
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_swtcl.h,v 1.3 2003/05/06 23:52:08 daenzer Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.

5
src/mesa/drivers/dri/r200/r200_tcl.c
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_tcl.c,v 1.2 2002/12/16 16:18:55 dawes Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the

4
src/mesa/drivers/dri/r200/r200_tcl.h
View file

@ -1,5 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_tcl.h,v 1.2 2002/12/16 16:18:55 dawes Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the

14
src/mesa/drivers/dri/r200/r200_tex.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_tex.c,v 1.2 2002/11/05 17:46:08 tsi Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
@ -296,7 +296,7 @@ r200ChooseTextureFormat( GLcontext *ctx, GLint internalFormat,
GLenum format, GLenum type )
{
r200ContextPtr rmesa = R200_CONTEXT(ctx);
const GLboolean do32bpt = ( rmesa->r200Screen->cpp == 4 );
const GLboolean do32bpt = rmesa->default32BitTextures;
switch ( internalFormat ) {
case 4:
@ -495,7 +495,7 @@ r200ValidateClientStorage( GLcontext *ctx, GLenum target,
* relaxed, but would need to store the image pitch somewhere,
* as packing details might change before image is uploaded:
*/
if (!r200IsAgpMemory( rmesa, pixels, srcHeight * srcRowStride ) ||
if (!r200IsGartMemory( rmesa, pixels, srcHeight * srcRowStride ) ||
(srcRowStride & 63))
return 0;
@ -626,8 +626,8 @@ static void r200TexImage2D( GLcontext *ctx, GLenum target, GLint level,
fprintf(stderr, "%s: Using normal storage\n", __FUNCTION__);
/* Normal path: copy (to cached memory) and eventually upload
* via another copy to agp memory and then a blit... Could
* eliminate one copy by going straight to (permanent) agp.
* via another copy to GART memory and then a blit... Could
* eliminate one copy by going straight to (permanent) GART.
*
* Note, this will call r200ChooseTextureFormat.
*/
@ -729,8 +729,8 @@ static void r200TexImage3D( GLcontext *ctx, GLenum target, GLint level,
fprintf(stderr, "%s: Using normal storage\n", __FUNCTION__);
/* Normal path: copy (to cached memory) and eventually upload
* via another copy to agp memory and then a blit... Could
* eliminate one copy by going straight to (permanent) agp.
* via another copy to GART memory and then a blit... Could
* eliminate one copy by going straight to (permanent) GART.
*
* Note, this will call r200ChooseTextureFormat.
*/

5
src/mesa/drivers/dri/r200/r200_tex.h
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_tex.h,v 1.1 2002/10/30 12:51:53 alanh Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the

25
src/mesa/drivers/dri/r200/r200_texmem.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_texmem.c,v 1.5 2002/12/17 00:32:56 dawes Exp $ */
/**************************************************************************
Copyright (C) Tungsten Graphics 2002. All Rights Reserved.
@ -35,6 +35,7 @@ SOFTWARE.
* Gareth Hughes <gareth@valinux.com>
*
*/
#include <errno.h>
#include "glheader.h"
@ -86,7 +87,7 @@ r200DestroyTexObj( r200ContextPtr rmesa, r200TexObjPtr t )
*/
static void r200UploadAGPClientSubImage( r200ContextPtr rmesa,
static void r200UploadGARTClientSubImage( r200ContextPtr rmesa,
r200TexObjPtr t,
struct gl_texture_image *texImage,
GLint hwlevel,
@ -124,7 +125,7 @@ static void r200UploadAGPClientSubImage( r200ContextPtr rmesa,
}
t->image[0][hwlevel].data = texImage->Data;
srcOffset = r200AgpOffsetFromVirtual( rmesa, texImage->Data );
srcOffset = r200GartOffsetFromVirtual( rmesa, texImage->Data );
assert( srcOffset != ~0 );
@ -181,16 +182,16 @@ static void r200UploadRectSubImage( r200ContextPtr rmesa,
height = texImage->Height;
dstPitch = t->pp_txpitch + 32;
if (rmesa->prefer_agp_client_texturing && texImage->IsClientData) {
/* In this case, could also use agp texturing. This is
if (rmesa->prefer_gart_client_texturing && texImage->IsClientData) {
/* In this case, could also use GART texturing. This is
* currently disabled, but has been tested & works.
*/
t->pp_txoffset = r200AgpOffsetFromVirtual( rmesa, texImage->Data );
t->pp_txoffset = r200GartOffsetFromVirtual( rmesa, texImage->Data );
t->pp_txpitch = texImage->RowStride * texFormat->TexelBytes - 32;
if (R200_DEBUG & DEBUG_TEXTURE)
fprintf(stderr,
"Using agp texturing for rectangular client texture\n");
"Using GART texturing for rectangular client texture\n");
/* Release FB memory allocated for this image:
*/
@ -202,21 +203,21 @@ static void r200UploadRectSubImage( r200ContextPtr rmesa,
}
}
else if (texImage->IsClientData) {
/* Data already in agp memory, with usable pitch.
/* Data already in GART memory, with usable pitch.
*/
GLuint srcPitch;
srcPitch = texImage->RowStride * texFormat->TexelBytes;
r200EmitBlit( rmesa,
blit_format,
srcPitch,
r200AgpOffsetFromVirtual( rmesa, texImage->Data ),
r200GartOffsetFromVirtual( rmesa, texImage->Data ),
dstPitch, t->bufAddr,
0, 0,
0, 0,
width, height );
}
else {
/* Data not in agp memory, or bad pitch.
/* Data not in GART memory, or bad pitch.
*/
for (done = 0; done < height ; ) {
struct r200_dma_region region;
@ -344,9 +345,9 @@ static void uploadSubImage( r200ContextPtr rmesa, r200TexObjPtr t,
}
else if (texImage->IsClientData) {
if ( R200_DEBUG & DEBUG_TEXTURE )
fprintf( stderr, "%s: image data is in agp client storage\n",
fprintf( stderr, "%s: image data is in GART client storage\n",
__FUNCTION__);
r200UploadAGPClientSubImage( rmesa, t, texImage, hwlevel,
r200UploadGARTClientSubImage( rmesa, t, texImage, hwlevel,
x, y, width, height );
return;
}

94
src/mesa/drivers/dri/r200/r200_texstate.c
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_texstate.c,v 1.3 2003/02/15 22:18:47 dawes Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the
@ -106,7 +105,7 @@ static void r200SetTexImages( r200ContextPtr rmesa,
const struct gl_texture_image *baseImage = tObj->Image[tObj->BaseLevel];
GLint curOffset;
GLint i;
GLint firstLevel=0, lastLevel=0, numLevels;
GLint numLevels;
GLint log2Width, log2Height, log2Depth;
/* Set the hardware texture format
@ -126,66 +125,15 @@ static void r200SetTexImages( r200ContextPtr rmesa,
}
/* Compute which mipmap levels we really want to send to the hardware.
* This depends on the base image size, GL_TEXTURE_MIN_LOD,
* GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL.
* Yes, this looks overly complicated, but it's all needed.
*/
if (R200_DEBUG & DEBUG_TEXTURE)
fprintf(stderr,
"%s: BaseLevel %d MinLod %f MaxLod %f MaxLevel %d\n",
__FUNCTION__,
tObj->BaseLevel, tObj->MinLod, tObj->MaxLod,
tObj->MaxLevel);
driCalculateTextureFirstLastLevel( (driTextureObject *) t );
log2Width = tObj->Image[t->base.firstLevel]->WidthLog2;
log2Height = tObj->Image[t->base.firstLevel]->HeightLog2;
log2Depth = tObj->Image[t->base.firstLevel]->DepthLog2;
switch (tObj->Target) {
case GL_TEXTURE_1D:
case GL_TEXTURE_2D:
case GL_TEXTURE_CUBE_MAP:
firstLevel = tObj->BaseLevel + (GLint)(tObj->MinLod + 0.5);
firstLevel = MAX2(firstLevel, tObj->BaseLevel);
lastLevel = tObj->BaseLevel + (GLint)(tObj->MaxLod + 0.5);
lastLevel = MAX2(lastLevel, tObj->BaseLevel);
lastLevel = MIN2(lastLevel, tObj->BaseLevel + baseImage->MaxLog2);
lastLevel = MIN2(lastLevel, tObj->MaxLevel);
lastLevel = MAX2(firstLevel, lastLevel); /* need at least one level */
log2Width = tObj->Image[firstLevel]->WidthLog2;
log2Height = tObj->Image[firstLevel]->HeightLog2;
log2Depth = 0;
break;
case GL_TEXTURE_3D:
firstLevel = tObj->BaseLevel;
lastLevel = tObj->BaseLevel;
log2Width = tObj->Image[firstLevel]->WidthLog2;
log2Height = tObj->Image[firstLevel]->HeightLog2;
log2Depth = tObj->Image[firstLevel]->DepthLog2;
break;
case GL_TEXTURE_RECTANGLE_NV:
firstLevel = lastLevel = 0;
log2Width = log2Height = 1; /* ? */
log2Depth = 0;
break;
default:
return;
}
/* save these values */
t->base.firstLevel = firstLevel;
t->base.lastLevel = lastLevel;
numLevels = lastLevel - firstLevel + 1;
if (R200_DEBUG & DEBUG_TEXTURE)
fprintf(stderr,
"%s: firstLevel %d last Level %d w,h: %d,%d log(w,h) %d,%d\n",
__FUNCTION__, firstLevel, lastLevel,
tObj->Image[firstLevel]->Width,
tObj->Image[firstLevel]->Height,
tObj->Image[firstLevel]->WidthLog2,
tObj->Image[firstLevel]->HeightLog2);
numLevels = t->base.lastLevel - t->base.firstLevel + 1;
assert(numLevels <= RADEON_MAX_TEXTURE_LEVELS);
@ -199,7 +147,7 @@ static void r200SetTexImages( r200ContextPtr rmesa,
const struct gl_texture_image *texImage;
GLuint size;
texImage = tObj->Image[i + firstLevel];
texImage = tObj->Image[i + t->base.firstLevel];
if ( !texImage )
break;
@ -219,10 +167,12 @@ static void r200SetTexImages( r200ContextPtr rmesa,
}
assert(size > 0);
if (curOffset & 0x1f) {
/* align to 32-byte offset */
/* Align to 32-byte offset. It is faster to do this unconditionally
* (no branch penalty).
*/
curOffset = (curOffset + 0x1f) & ~0x1f;
}
t->image[0][i].x = curOffset % BLIT_WIDTH_BYTES;
t->image[0][i].y = curOffset / BLIT_WIDTH_BYTES;
@ -305,17 +255,17 @@ static void r200SetTexImages( r200ContextPtr rmesa,
(log2Height << R200_FACE_HEIGHT_4_SHIFT));
}
t->pp_txsize = (((tObj->Image[firstLevel]->Width - 1) << 0) |
((tObj->Image[firstLevel]->Height - 1) << 16));
t->pp_txsize = (((tObj->Image[t->base.firstLevel]->Width - 1) << 0) |
((tObj->Image[t->base.firstLevel]->Height - 1) << 16));
/* Only need to round to nearest 32 for textures, but the blitter
* requires 64-byte aligned pitches, and we may/may not need the
* blitter. NPOT only!
*/
if (baseImage->IsCompressed)
t->pp_txpitch = (tObj->Image[firstLevel]->Width + 63) & ~(63);
t->pp_txpitch = (tObj->Image[t->base.firstLevel]->Width + 63) & ~(63);
else
t->pp_txpitch = ((tObj->Image[firstLevel]->Width * baseImage->TexFormat->TexelBytes) + 63) & ~(63);
t->pp_txpitch = ((tObj->Image[t->base.firstLevel]->Width * baseImage->TexFormat->TexelBytes) + 63) & ~(63);
t->pp_txpitch -= 32;
t->dirty_state = TEX_ALL;
@ -1561,6 +1511,12 @@ static GLboolean enable_tex_3d( GLcontext *ctx, int unit )
ASSERT(tObj->Target == GL_TEXTURE_3D);
/* R100 & R200 do not support mipmaps for 3D textures.
*/
if ( (tObj->MinFilter != GL_NEAREST) && (tObj->MinFilter != GL_LINEAR) ) {
return GL_FALSE;
}
if ( t->base.dirty_images[0] ) {
R200_FIREVERTICES( rmesa );
r200SetTexImages( rmesa, tObj );
@ -1633,7 +1589,7 @@ static GLboolean enable_tex_rect( GLcontext *ctx, int unit )
R200_FIREVERTICES( rmesa );
r200SetTexImages( rmesa, tObj );
r200UploadTexImages( rmesa, (r200TexObjPtr) tObj->DriverData, 0 );
if ( !t->base.memBlock && !rmesa->prefer_agp_client_texturing )
if ( !t->base.memBlock && !rmesa->prefer_gart_client_texturing )
return GL_FALSE;
}

9
src/mesa/drivers/dri/r200/r200_vtxfmt.c
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_vtxfmt.c,v 1.4 2003/05/06 23:52:08 daenzer Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the
@ -970,7 +969,7 @@ static void r200VtxFmtFlushVertices( GLcontext *ctx, GLuint flags )
*/
void r200VtxfmtInit( GLcontext *ctx )
void r200VtxfmtInit( GLcontext *ctx, GLboolean useCodegen )
{
r200ContextPtr rmesa = R200_CONTEXT( ctx );
GLvertexformat *vfmt = &(rmesa->vb.vtxfmt);
@ -1067,7 +1066,7 @@ void r200VtxfmtInit( GLcontext *ctx )
make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord1fARB );
make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord1fvARB );
r200InitCodegen( &rmesa->vb.codegen );
r200InitCodegen( &rmesa->vb.codegen, useCodegen );
}
static void free_funcs( struct dynfn *l )

9
src/mesa/drivers/dri/r200/r200_vtxfmt.h
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_vtxfmt.h,v 1.1 2002/10/30 12:51:53 alanh Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the
@ -44,7 +43,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
extern void r200VtxfmtUpdate( GLcontext *ctx );
extern void r200VtxfmtInit( GLcontext *ctx );
extern void r200VtxfmtInit( GLcontext *ctx, GLboolean useCodegen );
extern void r200VtxfmtInvalidate( GLcontext *ctx );
extern void r200VtxfmtDestroy( GLcontext *ctx );
extern void r200VtxfmtInitChoosers( GLvertexformat *vfmt );
@ -87,7 +86,7 @@ do { \
/*
*/
void r200InitCodegen( struct dfn_generators *gen );
void r200InitCodegen( struct dfn_generators *gen, GLboolean useCodegen );
void r200InitX86Codegen( struct dfn_generators *gen );
void r200InitSSECodegen( struct dfn_generators *gen );

9
src/mesa/drivers/dri/r200/r200_vtxfmt_c.c
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_vtxfmt_c.c,v 1.2 2002/12/16 16:18:56 dawes Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the
@ -860,7 +859,7 @@ static struct dynfn *codegen_noop( GLcontext *ctx, const int *key )
return 0;
}
void r200InitCodegen( struct dfn_generators *gen )
void r200InitCodegen( struct dfn_generators *gen, GLboolean useCodegen )
{
gen->Vertex3f = codegen_noop;
gen->Vertex3fv = codegen_noop;
@ -889,7 +888,7 @@ void r200InitCodegen( struct dfn_generators *gen )
gen->MultiTexCoord1fARB = codegen_noop;
gen->MultiTexCoord1fvARB = codegen_noop;
if (!getenv("R200_NO_CODEGEN")) {
if (useCodegen) {
#if defined(USE_X86_ASM)
r200InitX86Codegen( gen );
#endif

5
src/mesa/drivers/dri/r200/r200_vtxfmt_sse.c
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_vtxfmt_sse.c,v 1.1 2002/10/30 12:51:53 alanh Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the

5
src/mesa/drivers/dri/r200/r200_vtxfmt_x86.c
View file

@ -1,6 +1,5 @@
/* $XFree86$ */
/**************************************************************************
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_vtxfmt_x86.c,v 1.2 2002/12/16 16:18:56 dawes Exp $ */
/*
Copyright (C) The Weather Channel, Inc. 2002. All Rights Reserved.
The Weather Channel (TM) funded Tungsten Graphics to develop the

266
src/mesa/drivers/dri/r200/r200_vtxtmp_x86.S
View file

@ -1,4 +1,4 @@
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_vtxtmp_x86.S,v 1.1 2002/10/30 12:51:53 alanh Exp $ */
/* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_vtxtmp_x86.S,v 1.2 2002/11/07 18:31:59 tsi Exp $ */
/**************************************************************************
Copyright 2002 Tungsten Graphics Inc., Cedar Park, Texas.
@ -32,16 +32,6 @@ x:
.data
.align 4
GLOBL( _x86_Normal3fv)
movl 4(%esp), %eax /* load 'v' off stack */
movl (%eax), %ecx /* load v[0] */
movl 4(%eax), %edx /* load v[1] */
movl 8(%eax), %eax /* load v[2] */
movl %ecx, 0 /* store v[0] to current vertex */
movl %edx, 4 /* store v[1] to current vertex */
movl %eax, 8 /* store v[2] to current vertex */
ret
GLOBL ( _x86_Normal3fv_end )
/*
vertex 3f vertex size 4
@ -218,19 +208,70 @@ GLOBL ( _x86_Vertex3fv )
.6: jmp *0
GLOBL ( _x86_Vertex3fv_end )
/*
Normal 3f
/**
* Generic handler for 2 float format data. This can be used for
* TexCoord2f and possibly other functions.
*/
GLOBL ( _x86_Normal3f )
movl $0x12345678, %edx
GLOBL ( _x86_Attribute2f )
movl $0x0, %edx
movl 4(%esp), %eax
movl 8(%esp), %ecx
movl %eax, (%edx)
movl 8(%esp), %eax
movl %eax, 4(%edx)
movl 12(%esp), %eax
movl %eax, 8(%edx)
movl %ecx, 4(%edx)
ret
GLOBL ( _x86_Normal3f_end )
GLOBL ( _x86_Attribute2f_end )
/**
* Generic handler for 2 float vector format data. This can be used for
* TexCoord2fv and possibly other functions.
*/
GLOBL( _x86_Attribute2fv)
movl 4(%esp), %eax /* load 'v' off stack */
movl (%eax), %ecx /* load v[0] */
movl 4(%eax), %eax /* load v[1] */
movl %ecx, 0 /* store v[0] to current vertex */
movl %eax, 4 /* store v[1] to current vertex */
ret
GLOBL ( _x86_Attribute2fv_end )
/**
* Generic handler for 3 float format data. This can be used for
* Normal3f, Color3f (when the color target is also float), or
* TexCoord3f.
*/
GLOBL ( _x86_Attribute3f )
movl 4(%esp), %ecx
movl 8(%esp), %edx
movl 12(%esp), %eax
movl %ecx, 0
movl %edx, 4
movl %eax, 8
ret
GLOBL ( _x86_Attribute3f_end )
/**
* Generic handler for 3 float vector format data. This can be used for
* Normal3f, Color3f (when the color target is also float), or
* TexCoord3f.
*/
GLOBL( _x86_Attribute3fv)
movl 4(%esp), %eax /* load 'v' off stack */
movl (%eax), %ecx /* load v[0] */
movl 4(%eax), %edx /* load v[1] */
movl 8(%eax), %eax /* load v[2] */
movl %ecx, 0 /* store v[0] to current vertex */
movl %edx, 4 /* store v[1] to current vertex */
movl %eax, 8 /* store v[2] to current vertex */
ret
GLOBL ( _x86_Attribute3fv_end )
/*
Color 4ubv_ub
@ -290,69 +331,13 @@ GLOBL( _x86_Color4ub_ub )
ret
GLOBL( _x86_Color4ub_ub_end )
/*
Color3fv_3f
*/
GLOBL( _x86_Color3fv_3f )
movl 4(%esp), %eax
movl $0, %edx
movl (%eax), %ecx
movl %ecx, (%edx)
movl 4(%eax), %ecx
movl %ecx, 4(%edx)
movl 8(%eax), %ecx
movl %ecx, 8(%edx)
ret
GLOBL( _x86_Color3fv_3f_end )
/*
Color3f_3f
MultiTexCoord2fv st0/st1
*/
GLOBL( _x86_Color3f_3f )
movl $0x12345678, %edx
movl 4(%esp), %eax
movl %eax, (%edx)
movl 8(%esp,1), %eax
movl %eax, 4(%edx)
movl 12(%esp), %eax
movl %eax, 8(%edx)
ret
GLOBL( _x86_Color3f_3f_end )
/*
TexCoord2fv
*/
GLOBL( _x86_TexCoord2fv )
movl 4(%esp), %eax
movl $0x12345678, %edx
movl (%eax), %ecx
movl 4(%eax), %eax
movl %ecx, (%edx)
movl %eax, 4(%edx)
ret
GLOBL( _x86_TexCoord2fv_end )
/*
TexCoord2f
*/
GLOBL( _x86_TexCoord2f )
movl $0x12345678, %edx
GLOBL( _x86_MultiTexCoord2fv )
movl 4(%esp), %eax
movl 8(%esp), %ecx
movl %eax, (%edx)
movl %ecx, 4(%edx)
ret
GLOBL( _x86_TexCoord2f_end )
/*
MultiTexCoord2fvARB st0/st1
*/
GLOBL( _x86_MultiTexCoord2fvARB )
movl 4(%esp), %eax
movl 8(%esp), %ecx
sub $0x84c0, %eax
and $1, %eax
movl (%ecx), %edx
shl $3, %eax
@ -360,15 +345,15 @@ GLOBL( _x86_MultiTexCoord2fvARB )
movl %edx, 0xdeadbeef(%eax)
movl %ecx, 0xdeadbeef(%eax)
ret
GLOBL( _x86_MultiTexCoord2fvARB_end )
GLOBL( _x86_MultiTexCoord2fv_end )
/*
MultiTexCoord2fvARB
MultiTexCoord2fv
*/
GLOBL( _x86_MultiTexCoord2fvARB_2 )
GLOBL( _x86_MultiTexCoord2fv_2 )
movl 4(%esp,1), %eax
movl 8(%esp,1), %ecx
sub $0x84c0, %eax
and $0x1, %eax
movl 0(,%eax,4), %edx
movl (%ecx), %eax
@ -376,35 +361,132 @@ GLOBL( _x86_MultiTexCoord2fvARB_2 )
movl 4(%ecx), %eax
movl %eax, 4(%edx)
ret
GLOBL( _x86_MultiTexCoord2fvARB_2_end )
GLOBL( _x86_MultiTexCoord2fv_2_end )
/*
MultiTexCoord2fARB st0/st1
MultiTexCoord2f st0/st1
*/
GLOBL( _x86_MultiTexCoord2fARB )
GLOBL( _x86_MultiTexCoord2f )
movl 4(%esp), %eax
movl 8(%esp), %edx
sub $0x84c0, %eax
movl 12(%esp), %ecx
and $1, %eax
shl $3, %eax
movl %edx, 0xdeadbeef(%eax)
movl %ecx, 0xdeadbeef(%eax)
ret
GLOBL( _x86_MultiTexCoord2fARB_end )
GLOBL( _x86_MultiTexCoord2f_end )
/*
MultiTexCoord2fARB
MultiTexCoord2f
*/
GLOBL( _x86_MultiTexCoord2fARB_2 )
GLOBL( _x86_MultiTexCoord2f_2 )
movl 4(%esp), %eax
movl 8(%esp), %edx
sub $0x84c0, %eax
movl 12(%esp,1), %ecx
and $1,%eax
movl 0(,%eax,4), %eax
movl %edx, (%eax)
movl %ecx, 4(%eax)
ret
GLOBL( _x86_MultiTexCoord2fARB_2_end )
GLOBL( _x86_MultiTexCoord2f_2_end )
/**
* This can be used as a template for either Color3fv (when the color
* target is also a 3f) or Normal3fv.
*/
GLOBL( _sse_Attribute3fv )
movl 4(%esp), %eax
movlps (%eax), %xmm0
movl 8(%eax), %eax
movlps %xmm0, 0
movl %eax, 8
ret
GLOBL( _sse_Attribute3fv_end )
/**
* This can be used as a template for either Color3f (when the color
* target is also a 3f) or Normal3f.
*/
GLOBL( _sse_Attribute3f )
movlps 4(%esp), %xmm0
movl 12(%esp), %eax
movlps %xmm0, 0
movl %eax, 8
ret
GLOBL( _sse_Attribute3f_end )
/**
* Generic handler for 2 float vector format data. This can be used for
* TexCoord2fv and possibly other functions.
*/
GLOBL( _sse_Attribute2fv )
movl 4(%esp), %eax
movlps (%eax), %xmm0
movlps %xmm0, 0
ret
GLOBL( _sse_Attribute2fv_end )
/**
* Generic handler for 2 float format data. This can be used for
* TexCoord2f and possibly other functions.
*/
GLOBL( _sse_Attribute2f )
movlps 4(%esp), %xmm0
movlps %xmm0, 0
ret
GLOBL( _sse_Attribute2f_end )
/*
MultiTexCoord2fv st0/st1
*/
GLOBL( _sse_MultiTexCoord2fv )
movl 4(%esp), %eax
movl 8(%esp), %ecx
and $1, %eax
movlps (%ecx), %xmm0
movlps %xmm0, 0xdeadbeef(,%eax,8)
ret
GLOBL( _sse_MultiTexCoord2fv_end )
/*
MultiTexCoord2fv
*/
GLOBL( _sse_MultiTexCoord2fv_2 )
movl 4(%esp), %eax
movl 8(%esp), %ecx
and $0x1, %eax
movl 0(,%eax,4), %edx
movlps (%ecx), %xmm0
movlps %xmm0, (%edx)
ret
GLOBL( _sse_MultiTexCoord2fv_2_end )
/*
MultiTexCoord2f st0/st1
*/
GLOBL( _sse_MultiTexCoord2f )
movl 4(%esp), %eax
and $1, %eax
movlps 8(%esp), %xmm0
movlps %xmm0, 0xdeadbeef(,%eax,8)
ret
GLOBL( _sse_MultiTexCoord2f_end )
/*
MultiTexCoord2f
*/
GLOBL( _sse_MultiTexCoord2f_2 )
movl 4(%esp), %eax
movlps 8(%esp), %xmm0
and $1,%eax
movl 0(,%eax,4), %eax
movlps %xmm0, (%eax)
ret
GLOBL( _sse_MultiTexCoord2f_2_end )

5
src/mesa/drivers/dri/radeon/Makefile.X11
View file

@ -1,4 +1,4 @@
# $Id: Makefile.X11,v 1.2 2003/10/20 02:17:33 jonsmirl Exp $
# $Id: Makefile.X11,v 1.3 2003/10/21 06:05:49 jonsmirl Exp $
# Mesa 3-D graphics library
# Version: 5.0
@ -49,7 +49,8 @@ DRIVER_SOURCES = radeon_context.c \
../common/mm.c \
../common/utils.c \
../common/texmem.c \
../common/vblank.c
../common/vblank.c \
../common/xmlconfig.c
SUBSET_DRIVER_SOURCES = \
radeon_subset_bitmap.c \

88
src/mesa/drivers/dri/radeon/radeon_context.c
View file

@ -1,4 +1,4 @@
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_context.c,v 1.7 2003/02/08 21:26:45 dawes Exp $ */
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_context.c,v 1.9 2003/09/24 02:43:12 dawes Exp $ */
/**************************************************************************
Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and
@ -69,6 +69,25 @@ int RADEON_DEBUG = (0);
#endif
/* Radeon configuration
*/
#include "xmlpool.h"
const char __driConfigOptions[] =
DRI_CONF_BEGIN
DRI_CONF_SECTION_PERFORMANCE
DRI_CONF_TCL_MODE(DRI_CONF_TCL_CODEGEN)
DRI_CONF_FTHROTTLE_MODE(DRI_CONF_FTHROTTLE_IRQS)
DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_DEF_INTERVAL_0)
DRI_CONF_SECTION_END
DRI_CONF_SECTION_QUALITY
DRI_CONF_PREFERRED_BPT(0,"0,16,32")
DRI_CONF_SECTION_END
DRI_CONF_SECTION_DEBUG
DRI_CONF_NO_RAST(false)
DRI_CONF_SECTION_END
DRI_CONF_END;
const GLuint __driNConfigOptions = 5;
/* Return the width and height of the given buffer.
*/
@ -102,8 +121,7 @@ static const GLubyte *radeonGetString( GLcontext *ctx, GLenum name )
offset = driGetRendererString( buffer, "Radeon", DRIVER_DATE,
agp_mode );
sprintf( & buffer[ offset ], "%s %sTCL",
( rmesa->dri.drmMinor < 3 ) ? " DRM-COMPAT" : "",
sprintf( & buffer[ offset ], "%sTCL",
!(rmesa->TclFallback & RADEON_TCL_FALLBACK_TCL_DISABLE)
? "" : "NO-" );
@ -229,6 +247,7 @@ radeonCreateContext( const __GLcontextModes *glVisual,
radeonContextPtr rmesa;
GLcontext *ctx, *shareCtx;
int i;
int tcl_mode, fthrottle_mode, preferred_bpt;
assert(glVisual);
assert(driContextPriv);
@ -258,14 +277,12 @@ radeonCreateContext( const __GLcontextModes *glVisual,
rmesa->dri.hwContext = driContextPriv->hHWContext;
rmesa->dri.hwLock = &sPriv->pSAREA->lock;
rmesa->dri.fd = sPriv->fd;
/* If we don't have 1.3, fallback to the 1.1 interfaces.
*/
if (getenv("RADEON_COMPAT") || sPriv->drmMinor < 3 )
rmesa->dri.drmMinor = 1;
else
rmesa->dri.drmMinor = sPriv->drmMinor;
/* Parse configuration files */
driParseConfigFiles (&rmesa->optionCache, &screen->optionCache,
screen->driScreen->myNum, "radeon");
rmesa->radeonScreen = screen;
rmesa->sarea = (RADEONSAREAPrivPtr)((GLubyte *)sPriv->pSAREA +
screen->sarea_priv_offset);
@ -291,6 +308,9 @@ radeonCreateContext( const __GLcontextModes *glVisual,
driSetTextureSwapCounterLocation( rmesa->texture_heaps[i],
& rmesa->c_textureSwaps );
}
preferred_bpt = driQueryOptioni (&rmesa->optionCache, "preferred_bpt");
rmesa->default32BitTextures =
( ( preferred_bpt == 0 && screen->cpp == 4 ) || preferred_bpt == 32 );
rmesa->swtcl.RenderIndex = ~0;
rmesa->lost_context = 1;
@ -338,7 +358,7 @@ radeonCreateContext( const __GLcontextModes *glVisual,
MIN2( ctx->Const.MaxArrayLockSize,
RADEON_BUFFER_SIZE / RADEON_MAX_TCL_VERTSIZE );
rmesa->boxes = (getenv("LIBGL_PERFORMANCE_BOXES") != NULL);
rmesa->boxes = 0;
/* Initialize the software rasterizer and helper modules.
*/
@ -392,22 +412,24 @@ radeonCreateContext( const __GLcontextModes *glVisual,
radeonInitState( rmesa );
radeonInitSwtcl( ctx );
fthrottle_mode = driQueryOptioni(&rmesa->optionCache, "fthrottle_mode");
rmesa->iw.irq_seq = -1;
rmesa->irqsEmitted = 0;
rmesa->do_irqs = (rmesa->radeonScreen->irq && !getenv("RADEON_NO_IRQS"));
rmesa->do_irqs = (rmesa->radeonScreen->irq != 0 &&
fthrottle_mode == DRI_CONF_FTHROTTLE_IRQS);
rmesa->do_usleeps = !getenv("RADEON_NO_USLEEPS");
rmesa->vblank_flags = (rmesa->do_irqs)
? driGetDefaultVBlankFlags() : VBLANK_FLAG_NO_IRQ;
rmesa->do_usleeps = (fthrottle_mode == DRI_CONF_FTHROTTLE_USLEEPS);
rmesa->vblank_flags = (rmesa->radeonScreen->irq != 0)
? driGetDefaultVBlankFlags(&rmesa->optionCache) : VBLANK_FLAG_NO_IRQ;
#ifndef _SOLO
rmesa->get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( "__glXGetUST" );
if ( rmesa->get_ust == NULL )
#endif
{
rmesa->get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( (const GLubyte *) "__glXGetUST" );
if ( rmesa->get_ust == NULL ) {
rmesa->get_ust = get_ust_nop;
}
#else
rmesa->get_ust = get_ust_nop;
#endif
(*rmesa->get_ust)( & rmesa->swap_ust );
@ -417,16 +439,11 @@ radeonCreateContext( const __GLcontextModes *glVisual,
debug_control );
#endif
if (getenv("RADEON_NO_RAST")) {
tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
if (driQueryOptionb(&rmesa->optionCache, "no_rast")) {
fprintf(stderr, "disabling 3D acceleration\n");
FALLBACK(rmesa, RADEON_FALLBACK_DISABLE, 1);
}
else if (getenv("RADEON_TCL_FORCE_ENABLE")) {
fprintf(stderr, "Enabling TCL support... this will probably crash\n");
fprintf(stderr, " your card if it isn't capable of TCL!\n");
rmesa->radeonScreen->chipset |= RADEON_CHIPSET_TCL;
} else if (getenv("RADEON_TCL_FORCE_DISABLE") ||
rmesa->dri.drmMinor < 3 ||
} else if (tcl_mode == DRI_CONF_TCL_SW ||
!(rmesa->radeonScreen->chipset & RADEON_CHIPSET_TCL)) {
rmesa->radeonScreen->chipset &= ~RADEON_CHIPSET_TCL;
fprintf(stderr, "disabling TCL support\n");
@ -434,8 +451,8 @@ radeonCreateContext( const __GLcontextModes *glVisual,
}
if (rmesa->radeonScreen->chipset & RADEON_CHIPSET_TCL) {
if (!getenv("RADEON_NO_VTXFMT"))
radeonVtxfmtInit( ctx );
if (tcl_mode >= DRI_CONF_TCL_VTXFMT)
radeonVtxfmtInit( ctx, tcl_mode >= DRI_CONF_TCL_CODEGEN );
_tnl_need_dlist_norm_lengths( ctx, GL_FALSE );
}
@ -478,9 +495,11 @@ void radeonDestroyContext( __DRIcontextPrivate *driContextPriv )
radeonFlushCmdBuf( rmesa, __FUNCTION__ );
}
if (!rmesa->TclFallback & RADEON_TCL_FALLBACK_TCL_DISABLE)
if (!getenv("RADEON_NO_VTXFMT"))
if (!(rmesa->TclFallback & RADEON_TCL_FALLBACK_TCL_DISABLE)) {
int tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
if (tcl_mode >= DRI_CONF_TCL_VTXFMT)
radeonVtxfmtDestroy( rmesa->glCtx );
}
/* free the Mesa context */
rmesa->glCtx->DriverCtx = NULL;
@ -497,8 +516,7 @@ void radeonDestroyContext( __DRIcontextPrivate *driContextPriv )
*/
int i;
/* this assert is not correct, default textures are always on swap list
assert( is_empty_list( & rmesa->swapped ) ); */
assert( is_empty_list( & rmesa->swapped ) );
for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
driDestroyTextureHeap( rmesa->texture_heaps[ i ] );
@ -506,6 +524,9 @@ void radeonDestroyContext( __DRIcontextPrivate *driContextPriv )
}
}
/* free the option cache */
driDestroyOptionCache (&rmesa->optionCache);
FREE( rmesa );
}
}
@ -556,6 +577,7 @@ radeonMakeCurrent( __DRIcontextPrivate *driContextPriv,
fprintf(stderr, "%s ctx %p\n", __FUNCTION__, newCtx->glCtx);
if ( newCtx->dri.drawable != driDrawPriv ) {
driDrawableInitVBlank( driDrawPriv, newCtx->vblank_flags );
newCtx->dri.drawable = driDrawPriv;
radeonUpdateWindow( newCtx->glCtx );
radeonUpdateViewportOffset( newCtx->glCtx );

7
src/mesa/drivers/dri/radeon/radeon_context.h
View file

@ -444,7 +444,7 @@ struct radeon_dma_buffer {
drmBufPtr buf;
};
#define GET_START(rvb) (rmesa->radeonScreen->agp_buffer_offset + \
#define GET_START(rvb) (rmesa->radeonScreen->gart_buffer_offset + \
(rvb)->address - rmesa->dma.buf0_address + \
(rvb)->start)
@ -690,6 +690,7 @@ struct radeon_context {
unsigned nr_heaps;
driTexHeap * texture_heaps[ RADEON_NR_TEX_HEAPS ];
driTextureObject swapped;
GLboolean default32BitTextures;
/* Rasterization and vertex state:
@ -769,6 +770,10 @@ struct radeon_context {
*/
struct radeon_dri_mirror dri;
/* Configuration cache
*/
driOptionCache optionCache;
/* Performance counters
*/

16
src/mesa/drivers/dri/radeon/radeon_ioctl.c
View file

@ -34,6 +34,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
* Gareth Hughes <gareth@valinux.com>
* Keith Whitwell <keith@tungstengraphics.com>
*/
#include <sched.h>
#include <errno.h>
@ -162,7 +163,6 @@ extern void radeonEmitVbufPrim( radeonContextPtr rmesa,
drmRadeonCmdHeader *cmd;
assert(rmesa->dri.drmMinor >= 3);
assert(!(primitive & RADEON_CP_VC_CNTL_PRIM_WALK_IND));
radeonEmitState( rmesa );
@ -254,7 +254,6 @@ GLushort *radeonAllocEltsOpenEnded( radeonContextPtr rmesa,
if (RADEON_DEBUG & DEBUG_IOCTL)
fprintf(stderr, "%s %d\n", __FUNCTION__, min_nr);
assert(rmesa->dri.drmMinor >= 3);
assert((primitive & RADEON_CP_VC_CNTL_PRIM_WALK_IND));
radeonEmitState( rmesa );
@ -317,7 +316,6 @@ void radeonEmitVertexAOS( radeonContextPtr rmesa,
rmesa->ioctl.vertex_offset = offset;
#else
drmRadeonCmdHeader *cmd;
assert(rmesa->dri.drmMinor >= 3);
if (RADEON_DEBUG & (DEBUG_PRIMS|DEBUG_IOCTL))
fprintf(stderr, "%s: vertex_size 0x%x offset 0x%x \n",
@ -356,7 +354,6 @@ void radeonEmitAOS( radeonContextPtr rmesa,
if (RADEON_DEBUG & DEBUG_IOCTL)
fprintf(stderr, "%s\n", __FUNCTION__);
assert(rmesa->dri.drmMinor >= 3);
cmd = (drmRadeonCmdHeader *)radeonAllocCmdBuf( rmesa, sz * sizeof(int),
__FUNCTION__ );
@ -531,8 +528,6 @@ void radeonFlushCmdBuf( radeonContextPtr rmesa, const char *caller )
int ret;
assert (rmesa->dri.drmMinor >= 3);
LOCK_HARDWARE( rmesa );
ret = radeonFlushCmdBufLocked( rmesa, caller );
@ -691,9 +686,6 @@ void radeonAllocDmaRegion( radeonContextPtr rmesa,
rmesa->dma.current.ptr += bytes; /* bug - if alignment > 7 */
rmesa->dma.current.start =
rmesa->dma.current.ptr = (rmesa->dma.current.ptr + 0x7) & ~0x7;
if ( rmesa->dri.drmMinor < 3 )
radeonRefillCurrentDmaRegion( rmesa );
}
void radeonAllocDmaRegionVerts( radeonContextPtr rmesa,
@ -719,7 +711,7 @@ static CARD32 radeonGetLastFrame (radeonContextPtr rmesa)
drmRadeonGetParam gp;
gp.param = RADEON_PARAM_LAST_FRAME;
gp.value = &frame;
gp.value = (int *)&frame;
ret = drmCommandWriteRead( rmesa->dri.fd, DRM_RADEON_GETPARAM,
&gp, sizeof(gp) );
}
@ -1012,7 +1004,7 @@ static void radeonClear( GLcontext *ctx, GLbitfield mask, GLboolean all,
drmRadeonGetParam gp;
gp.param = RADEON_PARAM_LAST_CLEAR;
gp.value = &clear;
gp.value = (int *)&clear;
ret = drmCommandWriteRead( rmesa->dri.fd,
DRM_RADEON_GETPARAM, &gp, sizeof(gp) );
} else
@ -1154,14 +1146,12 @@ void radeonFlush( GLcontext *ctx )
if (rmesa->dma.flush)
rmesa->dma.flush( rmesa );
if (rmesa->dri.drmMinor >= 3) {
if (!is_empty_list(&rmesa->hw.dirty))
radeonEmitState( rmesa );
if (rmesa->store.cmd_used)
radeonFlushCmdBuf( rmesa, __FUNCTION__ );
}
}
/* Make sure all commands have been sent to the hardware and have
* completed processing.

2
src/mesa/drivers/dri/radeon/radeon_lock.c
View file

@ -53,8 +53,6 @@ radeonUpdatePageFlipping( radeonContextPtr rmesa )
{
int use_back;
if (rmesa->dri.drmMinor < 3)
return;
rmesa->doPageFlip = rmesa->sarea->pfAllowPageFlip;

2
src/mesa/drivers/dri/radeon/radeon_maos.h
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_maos.h,v 1.1 2002/10/30 12:51:55 alanh Exp $ */
/**************************************************************************
Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and

4
src/mesa/drivers/dri/radeon/radeon_maos_arrays.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_maos_arrays.c,v 1.1 2002/10/30 12:51:55 alanh Exp $ */
/**************************************************************************
Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and
@ -409,7 +409,7 @@ static void emit_tex_vector( GLcontext *ctx,
/* Emit any changed arrays to new agp memory, re-emit a packet to
/* Emit any changed arrays to new GART memory, re-emit a packet to
* update the arrays.
*/
void radeonEmitArrays( GLcontext *ctx, GLuint inputs )

2
src/mesa/drivers/dri/radeon/radeon_maos_verts.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_maos_verts.c,v 1.1 2002/10/30 12:51:55 alanh Exp $ */
/**************************************************************************
Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and

2
src/mesa/drivers/dri/radeon/radeon_sanity.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_sanity.c,v 1.1 2002/10/30 12:51:55 alanh Exp $ */
/**************************************************************************
Copyright 2002 ATI Technologies Inc., Ontario, Canada, and

103
src/mesa/drivers/dri/radeon/radeon_screen.c
View file

@ -1,4 +1,4 @@
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_screen.c,v 1.6 2002/12/16 16:18:58 dawes Exp $ */
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_screen.c,v 1.7 2003/03/26 20:43:51 tsi Exp $ */
/**************************************************************************
Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and
@ -89,32 +89,26 @@ radeonScreenPtr radeonCreateScreen( __DRIscreenPrivate *sPriv )
return NULL;
}
if ( sPriv->drmMinor < 3 ||
getenv("RADEON_COMPAT")) {
fprintf( stderr, "Radeon DRI driver:\n\t"
"Compatibility mode for DRM driver version %d.%d.%d\n\t"
"TCL will be disabled, expect reduced performance\n\t"
"(prefer DRM radeon.o 1.3.x or newer)\n\t",
sPriv->drmMajor, sPriv->drmMinor, sPriv->drmPatch );
}
/* parse information in __driConfigOptions */
driParseOptionInfo (&screen->optionCache);
/* This is first since which regions we map depends on whether or
* not we are using a PCI card.
*/
screen->IsPCI = dri_priv->IsPCI;
if (sPriv->drmMinor >= 3) {
{
int ret;
drmRadeonGetParam gp;
gp.param = RADEON_PARAM_AGP_BUFFER_OFFSET;
gp.value = &screen->agp_buffer_offset;
gp.param = RADEON_PARAM_GART_BUFFER_OFFSET;
gp.value = &screen->gart_buffer_offset;
ret = drmCommandWriteRead( sPriv->fd, DRM_RADEON_GETPARAM,
&gp, sizeof(gp));
if (ret) {
fprintf(stderr, "drmRadeonGetParam (RADEON_PARAM_AGP_BUFFER_OFFSET): %d\n", ret);
FREE( screen );
fprintf(stderr, "drmRadeonGetParam (RADEON_PARAM_GART_BUFFER_OFFSET): %d\n", ret);
return NULL;
}
@ -166,20 +160,26 @@ radeonScreenPtr radeonCreateScreen( __DRIscreenPrivate *sPriv )
return NULL;
}
if ( !screen->IsPCI ) {
screen->agpTextures.handle = dri_priv->agpTexHandle;
screen->agpTextures.size = dri_priv->agpTexMapSize;
if ( dri_priv->gartTexHandle && dri_priv->gartTexMapSize ) {
unsigned char *RADEONMMIO = screen->mmio.map;
screen->gartTextures.handle = dri_priv->gartTexHandle;
screen->gartTextures.size = dri_priv->gartTexMapSize;
if ( drmMap( sPriv->fd,
screen->agpTextures.handle,
screen->agpTextures.size,
(drmAddressPtr)&screen->agpTextures.map ) ) {
screen->gartTextures.handle,
screen->gartTextures.size,
(drmAddressPtr)&screen->gartTextures.map ) ) {
drmUnmapBufs( screen->buffers );
drmUnmap( screen->status.map, screen->status.size );
drmUnmap( screen->mmio.map, screen->mmio.size );
FREE( screen );
__driUtilMessage("%s: IsPCI failed\n", __FUNCTION__);
__driUtilMessage("%s: drmMap failed for GART texture area\n", __FUNCTION__);
return NULL;
}
screen->gart_texture_offset = dri_priv->gartTexOffset + ( screen->IsPCI
? INREG( RADEON_AIC_LO_ADDR )
: ( ( INREG( RADEON_MC_AGP_LOCATION ) & 0x0ffffU ) << 16 ) );
}
screen->chipset = 0;
@ -215,21 +215,36 @@ radeonScreenPtr radeonCreateScreen( __DRIscreenPrivate *sPriv )
screen->logTexGranularity[RADEON_CARD_HEAP] =
dri_priv->log2TexGran;
if ( screen->IsPCI
|| getenv( "RADEON_AGPTEXTURING_FORCE_DISABLE" ) ) {
if ( !screen->gartTextures.map
|| getenv( "RADEON_GARTTEXTURING_FORCE_DISABLE" ) ) {
screen->numTexHeaps = RADEON_NR_TEX_HEAPS - 1;
screen->texOffset[RADEON_AGP_HEAP] = 0;
screen->texSize[RADEON_AGP_HEAP] = 0;
screen->logTexGranularity[RADEON_AGP_HEAP] = 0;
screen->texOffset[RADEON_GART_HEAP] = 0;
screen->texSize[RADEON_GART_HEAP] = 0;
screen->logTexGranularity[RADEON_GART_HEAP] = 0;
} else {
screen->numTexHeaps = RADEON_NR_TEX_HEAPS;
screen->texOffset[RADEON_AGP_HEAP] =
dri_priv->agpTexOffset + RADEON_AGP_TEX_OFFSET;
screen->texSize[RADEON_AGP_HEAP] = dri_priv->agpTexMapSize;
screen->logTexGranularity[RADEON_AGP_HEAP] =
dri_priv->log2AGPTexGran;
screen->texOffset[RADEON_GART_HEAP] = screen->gart_texture_offset;
screen->texSize[RADEON_GART_HEAP] = dri_priv->gartTexMapSize;
screen->logTexGranularity[RADEON_GART_HEAP] =
dri_priv->log2GARTTexGran;
}
#ifndef _SOLO
if ( driCompareGLXAPIVersion( 20030813 ) >= 0 ) {
PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
(PFNGLXSCRENABLEEXTENSIONPROC) glXGetProcAddress( (const GLubyte *) "__glXScrEnableExtension" );
void * const psc = sPriv->psc->screenConfigs;
if ( glx_enable_extension != NULL ) {
if ( screen->irq != 0 ) {
(*glx_enable_extension)( psc, "GLX_SGI_swap_control" );
(*glx_enable_extension)( psc, "GLX_SGI_video_sync" );
(*glx_enable_extension)( psc, "GLX_MESA_swap_control" );
}
(*glx_enable_extension)( psc, "GLX_MESA_swap_frame_usage" );
}
}
#endif
screen->driScreen = sPriv;
screen->sarea_priv_offset = dri_priv->sarea_priv_offset;
return screen;
@ -244,14 +259,16 @@ void radeonDestroyScreen( __DRIscreenPrivate *sPriv )
if (!screen)
return;
if ( !screen->IsPCI ) {
drmUnmap( screen->agpTextures.map,
screen->agpTextures.size );
if ( screen->gartTextures.map ) {
drmUnmap( screen->gartTextures.map, screen->gartTextures.size );
}
drmUnmapBufs( screen->buffers );
drmUnmap( screen->status.map, screen->status.size );
drmUnmap( screen->mmio.map, screen->mmio.size );
/* free all option information */
driDestroyOptionInfo (&screen->optionCache);
FREE( screen );
sPriv->private = NULL;
}
@ -368,10 +385,13 @@ void *__driCreateScreen(struct DRIDriverRec *driver,
}
#endif
#ifndef _SOLO
/* This function is called by libGL.so as soon as libGL.so is loaded.
/**
* This function is called by libGL.so as soon as libGL.so is loaded.
* This is where we'd register new extension functions with the dispatcher.
*
* \todo This interface has been deprecated, so we should probably remove
* this function before the next XFree86 release.
*/
void
__driRegisterExtensions( void )
@ -381,19 +401,18 @@ __driRegisterExtensions( void )
if ( driCompareGLXAPIVersion( 20030317 ) >= 0 ) {
glx_enable_extension = (PFNGLXENABLEEXTENSIONPROC)
glXGetProcAddress( "__glXEnableExtension" );
glXGetProcAddress( (const GLubyte *) "__glXEnableExtension" );
if ( glx_enable_extension != NULL ) {
glx_enable_extension( "GLX_SGI_swap_control", GL_FALSE );
glx_enable_extension( "GLX_SGI_video_sync", GL_FALSE );
glx_enable_extension( "GLX_MESA_swap_control", GL_FALSE );
glx_enable_extension( "GLX_MESA_swap_frame_usage", GL_FALSE );
(*glx_enable_extension)( "GLX_SGI_swap_control", GL_FALSE );
(*glx_enable_extension)( "GLX_SGI_video_sync", GL_FALSE );
(*glx_enable_extension)( "GLX_MESA_swap_control", GL_FALSE );
(*glx_enable_extension)( "GLX_MESA_swap_frame_usage", GL_FALSE );
}
}
}
#endif
/**
* Get information about previous buffer swaps.
*/

9
src/mesa/drivers/dri/radeon/radeon_screen.h
View file

@ -48,6 +48,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "radeon_dri.h"
#include "radeon_reg.h"
#include "radeon_sarea.h"
#include "xmlconfig.h"
typedef struct {
@ -83,7 +84,7 @@ typedef struct {
radeonRegionRec mmio;
radeonRegionRec status;
radeonRegionRec agpTextures;
radeonRegionRec gartTextures;
drmBufMapPtr buffers;
@ -91,7 +92,11 @@ typedef struct {
__DRIscreenPrivate *driScreen;
unsigned int sarea_priv_offset;
unsigned int agp_buffer_offset; /* offset in card memory space */
unsigned int gart_buffer_offset; /* offset in card memory space */
unsigned int gart_texture_offset; /* offset in card memory space */
/* Configuration cache with default values for all contexts */
driOptionCache optionCache;
} radeonScreenRec, *radeonScreenPtr;
extern radeonScreenPtr radeonCreateScreen( __DRIscreenPrivate *sPriv );

2
src/mesa/drivers/dri/radeon/radeon_state_init.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_state_init.c,v 1.3 2003/02/22 06:21:11 dawes Exp $ */
/*
* Copyright 2000, 2001 VA Linux Systems Inc., Fremont, California.
*

92
src/mesa/drivers/dri/radeon/radeon_swtcl.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_swtcl.c,v 1.6 2003/05/06 23:52:08 daenzer Exp $ */
/**************************************************************************
Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and
@ -67,7 +67,6 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define RADEON_MAX_SETUP 0x40
static void flush_last_swtcl_prim( radeonContextPtr rmesa );
static void flush_last_swtcl_prim_compat( radeonContextPtr rmesa );
static struct {
void (*emit)( GLcontext *, GLuint, GLuint, void *, GLuint );
@ -282,7 +281,6 @@ static void radeonRenderStart( GLcontext *ctx )
}
if (rmesa->dma.flush != 0 &&
rmesa->dma.flush != flush_last_swtcl_prim_compat &&
rmesa->dma.flush != flush_last_swtcl_prim)
rmesa->dma.flush( rmesa );
}
@ -381,7 +379,7 @@ static void flush_last_swtcl_prim( radeonContextPtr rmesa )
if (rmesa->dma.current.buf) {
struct radeon_dma_region *current = &rmesa->dma.current;
GLuint current_offset = (rmesa->radeonScreen->agp_buffer_offset +
GLuint current_offset = (rmesa->radeonScreen->gart_buffer_offset +
current->buf->buf->idx * RADEON_BUFFER_SIZE +
current->start);
@ -408,46 +406,6 @@ static void flush_last_swtcl_prim( radeonContextPtr rmesa )
}
static void flush_last_swtcl_prim_compat( radeonContextPtr rmesa )
{
struct radeon_dma_region *current = &rmesa->dma.current;
if (RADEON_DEBUG & DEBUG_IOCTL)
fprintf(stderr, "%s buf %p start %d ptr %d\n",
__FUNCTION__,
current->buf,
current->start,
current->ptr);
assert (!(rmesa->swtcl.hw_primitive & RADEON_CP_VC_CNTL_PRIM_WALK_IND));
assert (current->start +
rmesa->swtcl.numverts * rmesa->swtcl.vertex_size * 4 ==
current->ptr);
assert (current->start == 0);
rmesa->dma.flush = 0;
if (current->ptr && current->buf) {
assert (current->buf->refcount == 1);
radeonCompatEmitPrimitive( rmesa,
rmesa->swtcl.vertex_format,
rmesa->swtcl.hw_primitive,
rmesa->swtcl.numverts);
/* The buffer has been released:
*/
FREE(current->buf);
current->buf = 0;
current->start = 0;
current->ptr = current->end;
}
rmesa->swtcl.numverts = 0;
}
/* Alloc space in the current dma region.
*/
static __inline void *radeonAllocDmaLowVerts( radeonContextPtr rmesa,
@ -460,22 +418,18 @@ static __inline void *radeonAllocDmaLowVerts( radeonContextPtr rmesa,
if (!rmesa->dma.flush) {
rmesa->glCtx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;
if (rmesa->dri.drmMinor == 1)
rmesa->dma.flush = flush_last_swtcl_prim_compat;
else
rmesa->dma.flush = flush_last_swtcl_prim;
}
assert( vsize == rmesa->swtcl.vertex_size * 4 );
assert( rmesa->dma.flush == flush_last_swtcl_prim ||
rmesa->dma.flush == flush_last_swtcl_prim_compat);
assert( rmesa->dma.flush == flush_last_swtcl_prim );
assert (rmesa->dma.current.start +
rmesa->swtcl.numverts * rmesa->swtcl.vertex_size * 4 ==
rmesa->dma.current.ptr);
{
char *head = rmesa->dma.current.address + rmesa->dma.current.ptr;
GLubyte *head = (GLubyte *)(rmesa->dma.current.address + rmesa->dma.current.ptr);
rmesa->dma.current.ptr += bytes;
rmesa->swtcl.numverts += nverts;
return head;
@ -624,7 +578,7 @@ do { \
\
radeonEmitVertexAOS( rmesa, \
rmesa->swtcl.vertex_size, \
(rmesa->radeonScreen->agp_buffer_offset + \
(rmesa->radeonScreen->gart_buffer_offset + \
rmesa->swtcl.indexed_verts.buf->buf->idx * \
RADEON_BUFFER_SIZE + \
rmesa->swtcl.indexed_verts.start)); \
@ -683,15 +637,6 @@ static GLboolean radeon_run_render( GLcontext *ctx,
ctx->Line.StippleFlag) /* GH: THIS IS A HACK!!! */
return GL_TRUE;
if (rmesa->dri.drmMinor < 3) {
/* drm 1.1 doesn't support vertex primitives starting in the
* middle of a buffer. It doesn't support sane indexed vertices
* either. drm 1.2 fixes both of these problems, but we don't have a
* compatibility layer to that version yet.
*/
return GL_TRUE;
}
tnl->Driver.Render.Start( ctx );
if (VB->Elts) {
@ -952,7 +897,6 @@ static void radeonResetLineStipple( GLcontext *ctx );
#define RADEON_TWOSIDE_BIT 0x01
#define RADEON_UNFILLED_BIT 0x02
#define RADEON_OFFSET_BIT 0x04 /* drmMinor == 1 */
#define RADEON_MAX_TRIFUNC 0x08
@ -965,7 +909,7 @@ static struct {
#define DO_FALLBACK 0
#define DO_OFFSET (IND & RADEON_OFFSET_BIT)
#define DO_OFFSET 0
#define DO_UNFILLED (IND & RADEON_UNFILLED_BIT)
#define DO_TWOSIDE (IND & RADEON_TWOSIDE_BIT)
#define DO_FLAT 0
@ -1051,22 +995,6 @@ static struct {
#define TAG(x) x##_twoside_unfilled
#include "tnl_dd/t_dd_tritmp.h"
#define IND (RADEON_OFFSET_BIT)
#define TAG(x) x##_offset
#include "tnl_dd/t_dd_tritmp.h"
#define IND (RADEON_TWOSIDE_BIT|RADEON_OFFSET_BIT)
#define TAG(x) x##_twoside_offset
#include "tnl_dd/t_dd_tritmp.h"
#define IND (RADEON_UNFILLED_BIT|RADEON_OFFSET_BIT)
#define TAG(x) x##_unfilled_offset
#include "tnl_dd/t_dd_tritmp.h"
#define IND (RADEON_TWOSIDE_BIT|RADEON_UNFILLED_BIT|RADEON_OFFSET_BIT)
#define TAG(x) x##_twoside_unfilled_offset
#include "tnl_dd/t_dd_tritmp.h"
static void init_rast_tab( void )
{
@ -1074,10 +1002,6 @@ static void init_rast_tab( void )
init_twoside();
init_unfilled();
init_twoside_unfilled();
init_offset();
init_twoside_offset();
init_unfilled_offset();
init_twoside_unfilled_offset();
}
/**********************************************************************/
@ -1136,8 +1060,6 @@ void radeonChooseRenderState( GLcontext *ctx )
if (flags & DD_TRI_LIGHT_TWOSIDE) index |= RADEON_TWOSIDE_BIT;
if (flags & DD_TRI_UNFILLED) index |= RADEON_UNFILLED_BIT;
if ((flags & DD_TRI_OFFSET) &&
rmesa->dri.drmMinor == 1) index |= RADEON_OFFSET_BIT;
if (index != rmesa->swtcl.RenderIndex) {
tnl->Driver.Render.Points = rast_tab[index].points;
@ -1300,7 +1222,7 @@ void radeonInitSwtcl( GLcontext *ctx )
tnl->Driver.Render.ResetLineStipple = radeonResetLineStipple;
tnl->Driver.Render.BuildVertices = radeonBuildVertices;
rmesa->swtcl.verts = ALIGN_MALLOC( size * 16 * 4, 32 );
rmesa->swtcl.verts = (GLubyte *)ALIGN_MALLOC( size * 16 * 4, 32 );
rmesa->swtcl.RenderIndex = ~0;
rmesa->swtcl.render_primitive = GL_TRIANGLES;
rmesa->swtcl.hw_primitive = 0;

2
src/mesa/drivers/dri/radeon/radeon_tcl.h
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_tcl.h,v 1.2 2003/02/08 21:26:45 dawes Exp $ */
/**************************************************************************
Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and

4
src/mesa/drivers/dri/radeon/radeon_texmem.c
View file

@ -112,8 +112,8 @@ static void radeonUploadRectSubImage( radeonContextPtr rmesa,
height = texImage->Height;
dstPitch = t->pp_txpitch + 32;
{ /* FIXME: prefer AGP-texturing if possible */
/* Data not in agp memory, or bad pitch.
{ /* FIXME: prefer GART-texturing if possible */
/* Data not in GART memory, or bad pitch.
*/
for (done = 0; done < height ; ) {
struct radeon_dma_region region;

57
src/mesa/drivers/dri/radeon/radeon_texstate.c
View file

@ -107,7 +107,7 @@ static void radeonSetTexImages( radeonContextPtr rmesa,
const struct gl_texture_image *baseImage = tObj->Image[tObj->BaseLevel];
GLint curOffset;
GLint i;
GLint firstLevel=0, lastLevel=0, numLevels;
GLint numLevels;
GLint log2Width, log2Height, log2Depth;
/* Set the hardware texture format
@ -127,40 +127,15 @@ static void radeonSetTexImages( radeonContextPtr rmesa,
}
/* Compute which mipmap levels we really want to send to the hardware.
* This depends on the base image size, GL_TEXTURE_MIN_LOD,
* GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL.
* Yes, this looks overly complicated, but it's all needed.
*/
switch (tObj->Target) {
case GL_TEXTURE_1D:
case GL_TEXTURE_2D:
firstLevel = tObj->BaseLevel + (GLint)(tObj->MinLod + 0.5);
firstLevel = MAX2(firstLevel, tObj->BaseLevel);
lastLevel = tObj->BaseLevel + (GLint)(tObj->MaxLod + 0.5);
lastLevel = MAX2(lastLevel, tObj->BaseLevel);
lastLevel = MIN2(lastLevel, tObj->BaseLevel + baseImage->MaxLog2);
lastLevel = MIN2(lastLevel, tObj->MaxLevel);
lastLevel = MAX2(firstLevel, lastLevel); /* need at least one level */
log2Width = tObj->Image[firstLevel]->WidthLog2;
log2Height = tObj->Image[firstLevel]->HeightLog2;
log2Depth = 0;
break;
case GL_TEXTURE_RECTANGLE_NV:
firstLevel = lastLevel = 0;
log2Width = log2Height = 1; /* ? */
log2Depth = 0;
break;
default:
return;
}
/* save these values */
t->base.firstLevel = firstLevel;
t->base.lastLevel = lastLevel;
driCalculateTextureFirstLastLevel( (driTextureObject *) t );
log2Width = tObj->Image[t->base.firstLevel]->WidthLog2;
log2Height = tObj->Image[t->base.firstLevel]->HeightLog2;
log2Depth = tObj->Image[t->base.firstLevel]->DepthLog2;
numLevels = lastLevel - firstLevel + 1;
numLevels = t->base.lastLevel - t->base.firstLevel + 1;
assert(numLevels <= RADEON_MAX_TEXTURE_LEVELS);
@ -174,7 +149,7 @@ static void radeonSetTexImages( radeonContextPtr rmesa,
const struct gl_texture_image *texImage;
GLuint size;
texImage = tObj->Image[i + firstLevel];
texImage = tObj->Image[i + t->base.firstLevel];
if ( !texImage )
break;
@ -194,10 +169,12 @@ static void radeonSetTexImages( radeonContextPtr rmesa,
}
assert(size > 0);
if (curOffset & 0x1f) {
/* align to 32-byte offset */
/* Align to 32-byte offset. It is faster to do this unconditionally
* (no branch penalty).
*/
curOffset = (curOffset + 0x1f) & ~0x1f;
}
t->image[0][i].x = curOffset % BLIT_WIDTH_BYTES;
t->image[0][i].y = curOffset / BLIT_WIDTH_BYTES;
@ -237,17 +214,17 @@ static void radeonSetTexImages( radeonContextPtr rmesa,
t->pp_txformat |= ((log2Width << RADEON_TXFORMAT_WIDTH_SHIFT) |
(log2Height << RADEON_TXFORMAT_HEIGHT_SHIFT));
t->pp_txsize = (((tObj->Image[firstLevel]->Width - 1) << 0) |
((tObj->Image[firstLevel]->Height - 1) << 16));
t->pp_txsize = (((tObj->Image[t->base.firstLevel]->Width - 1) << 0) |
((tObj->Image[t->base.firstLevel]->Height - 1) << 16));
/* Only need to round to nearest 32 for textures, but the blitter
* requires 64-byte aligned pitches, and we may/may not need the
* blitter. NPOT only!
*/
if (baseImage->IsCompressed)
t->pp_txpitch = (tObj->Image[firstLevel]->Width + 63) & ~(63);
t->pp_txpitch = (tObj->Image[t->base.firstLevel]->Width + 63) & ~(63);
else
t->pp_txpitch = ((tObj->Image[firstLevel]->Width * baseImage->TexFormat->TexelBytes) + 63) & ~(63);
t->pp_txpitch = ((tObj->Image[t->base.firstLevel]->Width * baseImage->TexFormat->TexelBytes) + 63) & ~(63);
t->pp_txpitch -= 32;
t->dirty_state = TEX_ALL;
@ -1500,7 +1477,7 @@ static GLboolean enable_tex_rect( GLcontext *ctx, int unit )
RADEON_FIREVERTICES( rmesa );
radeonSetTexImages( rmesa, tObj );
radeonUploadTexImages( rmesa, (radeonTexObjPtr) tObj->DriverData, 0 );
if ( !t->base.memBlock /* && !rmesa->prefer_agp_client_texturing FIXME */ ) {
if ( !t->base.memBlock /* && !rmesa->prefer_gart_client_texturing FIXME */ ) {
fprintf(stderr, "%s: upload failed\n", __FUNCTION__);
return GL_FALSE;
}

6
src/mesa/drivers/dri/radeon/radeon_vtxfmt.c
View file

@ -1,4 +1,4 @@
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt.c,v 1.5 2002/12/16 16:18:59 dawes Exp $ */
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt.c,v 1.6 2003/05/06 23:52:08 daenzer Exp $ */
/**************************************************************************
Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and
@ -937,7 +937,7 @@ static void radeonVtxfmtFlushVertices( GLcontext *ctx, GLuint flags )
*/
void radeonVtxfmtInit( GLcontext *ctx )
void radeonVtxfmtInit( GLcontext *ctx, GLboolean useCodegen )
{
radeonContextPtr rmesa = RADEON_CONTEXT( ctx );
GLvertexformat *vfmt = &(rmesa->vb.vtxfmt);
@ -1034,7 +1034,7 @@ void radeonVtxfmtInit( GLcontext *ctx )
make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord1fARB );
make_empty_list( &rmesa->vb.dfn_cache.MultiTexCoord1fvARB );
radeonInitCodegen( &rmesa->vb.codegen );
radeonInitCodegen( &rmesa->vb.codegen, useCodegen );
}
static void free_funcs( struct dynfn *l )

4
src/mesa/drivers/dri/radeon/radeon_vtxfmt.h
View file

@ -42,7 +42,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
extern void radeonVtxfmtUpdate( GLcontext *ctx );
extern void radeonVtxfmtInit( GLcontext *ctx );
extern void radeonVtxfmtInit( GLcontext *ctx, GLboolean useCodegen );
extern void radeonVtxfmtInvalidate( GLcontext *ctx );
extern void radeonVtxfmtDestroy( GLcontext *ctx );
extern void radeonVtxfmtInitChoosers( GLvertexformat *vfmt );
@ -84,7 +84,7 @@ do { \
/*
*/
void radeonInitCodegen( struct dfn_generators *gen );
void radeonInitCodegen( struct dfn_generators *gen, GLboolean useCodegen );
void radeonInitX86Codegen( struct dfn_generators *gen );
void radeonInitSSECodegen( struct dfn_generators *gen );

6
src/mesa/drivers/dri/radeon/radeon_vtxfmt_c.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt_c.c,v 1.2 2002/12/16 16:18:59 dawes Exp $ */
/**************************************************************************
Copyright 2002 ATI Technologies Inc., Ontario, Canada, and
@ -864,7 +864,7 @@ static struct dynfn *codegen_noop( GLcontext *ctx, int key )
return 0;
}
void radeonInitCodegen( struct dfn_generators *gen )
void radeonInitCodegen( struct dfn_generators *gen, GLboolean useCodegen )
{
gen->Vertex3f = codegen_noop;
gen->Vertex3fv = codegen_noop;
@ -893,7 +893,7 @@ void radeonInitCodegen( struct dfn_generators *gen )
gen->MultiTexCoord1fARB = codegen_noop;
gen->MultiTexCoord1fvARB = codegen_noop;
if (!getenv("RADEON_NO_CODEGEN")) {
if (useCodegen) {
#if defined(USE_X86_ASM)
radeonInitX86Codegen( gen );
#endif

2
src/mesa/drivers/dri/radeon/radeon_vtxfmt_sse.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt_sse.c,v 1.1 2002/10/30 12:51:58 alanh Exp $ */
/**************************************************************************
Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and

2
src/mesa/drivers/dri/radeon/radeon_vtxfmt_x86.c
View file

@ -1,4 +1,4 @@
/* $XFree86$ */
/* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_vtxfmt_x86.c,v 1.2 2002/12/21 17:02:16 dawes Exp $ */
/**************************************************************************
Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and

20
src/mesa/drivers/dri/radeon/server/radeon.h
View file

@ -108,11 +108,11 @@ typedef struct {
* \name AGP
*/
/*@{*/
drmSize agpSize; /**< \brief AGP map size */
drmHandle agpMemHandle; /**< \brief AGP map handle */
unsigned long agpOffset; /**< \brief AGP offset */
int agpMode; /**< \brief AGP mode */
int agpFastWrite;
drmSize gartSize; /**< \brief AGP map size */
drmHandle gartMemHandle; /**< \brief AGP map handle */
unsigned long gartOffset; /**< \brief AGP offset */
int gartMode; /**< \brief AGP mode */
int gartFastWrite;
/*@}*/
/**
@ -144,11 +144,11 @@ typedef struct {
* \name CP AGP Texture data
*/
/*@{*/
unsigned long agpTexStart; /**< \brief Offset into AGP space */
drmHandle agpTexHandle; /**< \brief Handle from drmAddMap() */
drmSize agpTexMapSize; /**< \brief Size of map */
int agpTexSize; /**< \brief Size of AGP tex space (in MB) */
int log2AGPTexGran;
unsigned long gartTexStart; /**< \brief Offset into AGP space */
drmHandle gartTexHandle; /**< \brief Handle from drmAddMap() */
drmSize gartTexMapSize; /**< \brief Size of map */
int gartTexSize; /**< \brief Size of AGP tex space (in MB) */
int log2GARTTexGran;
/*@}*/
int drmMinor; /**< \brief DRM device minor number */

15
src/mesa/drivers/dri/radeon/server/radeon_common.h
View file

@ -31,7 +31,7 @@
* Converted to common header format:
* Jens Owen <jens@tungstengraphics.com>
*
* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/xf86drmRadeon.h,v 1.6 2001/04/16 15:02:13 tsi Exp $
* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/ati/radeon_common.h,v 1.2 2003/04/07 01:22:09 martin Exp $
*
*/
@ -70,6 +70,7 @@
#define DRM_RADEON_INIT_HEAP 0x15
#define DRM_RADEON_IRQ_EMIT 0x16
#define DRM_RADEON_IRQ_WAIT 0x17
#define DRM_RADEON_CP_RESUME 0x18
#define DRM_RADEON_MAX_DRM_COMMAND_INDEX 0x39
@ -94,7 +95,7 @@ typedef struct {
unsigned long sarea_priv_offset;
int is_pci;
int cp_mode;
int agp_size;
int gart_size;
int ring_size;
int usec_timeout;
@ -109,7 +110,7 @@ typedef struct {
unsigned long ring_offset;
unsigned long ring_rptr_offset;
unsigned long buffers_offset;
unsigned long agp_textures_offset;
unsigned long gart_textures_offset;
} drmRadeonInit;
typedef struct {
@ -404,22 +405,22 @@ typedef struct drm_radeon_getparam {
void *value;
} drmRadeonGetParam;
#define RADEON_PARAM_AGP_BUFFER_OFFSET 1
#define RADEON_PARAM_GART_BUFFER_OFFSET 1
#define RADEON_PARAM_LAST_FRAME 2
#define RADEON_PARAM_LAST_DISPATCH 3
#define RADEON_PARAM_LAST_CLEAR 4
#define RADEON_PARAM_IRQ_NR 5
#define RADEON_PARAM_AGP_BASE 6
#define RADEON_PARAM_GART_BASE 6
#define RADEON_MEM_REGION_AGP 1
#define RADEON_MEM_REGION_GART 1
#define RADEON_MEM_REGION_FB 2
typedef struct drm_radeon_mem_alloc {
int region;
int alignment;
int size;
int *region_offset; /* offset from start of fb or agp */
int *region_offset; /* offset from start of fb or GART */
} drmRadeonMemAlloc;
typedef struct drm_radeon_mem_free {

98
src/mesa/drivers/dri/radeon/server/radeon_dri.c
View file

@ -318,7 +318,7 @@ static int RADEONDRIAgpInit( const DRIDriverContext *ctx, RADEONInfoPtr info)
int s, l;
if (drmAgpAcquire(ctx->drmFD) < 0) {
fprintf(stderr, "[agp] AGP not available\n");
fprintf(stderr, "[gart] AGP not available\n");
return 0;
}
@ -334,40 +334,40 @@ static int RADEONDRIAgpInit( const DRIDriverContext *ctx, RADEONInfoPtr info)
/* Disable fast write entirely - too many lockups.
*/
mode &= ~RADEON_AGP_MODE_MASK;
switch (info->agpMode) {
switch (info->gartMode) {
case 4: mode |= RADEON_AGP_4X_MODE;
case 2: mode |= RADEON_AGP_2X_MODE;
case 1: default: mode |= RADEON_AGP_1X_MODE;
}
if (drmAgpEnable(ctx->drmFD, mode) < 0) {
fprintf(stderr, "[agp] AGP not enabled\n");
fprintf(stderr, "[gart] AGP not enabled\n");
drmAgpRelease(ctx->drmFD);
return 0;
}
info->agpOffset = 0;
info->gartOffset = 0;
if ((ret = drmAgpAlloc(ctx->drmFD, info->agpSize*1024*1024, 0, NULL,
&info->agpMemHandle)) < 0) {
fprintf(stderr, "[agp] Out of memory (%d)\n", ret);
if ((ret = drmAgpAlloc(ctx->drmFD, info->gartSize*1024*1024, 0, NULL,
&info->gartMemHandle)) < 0) {
fprintf(stderr, "[gart] Out of memory (%d)\n", ret);
drmAgpRelease(ctx->drmFD);
return 0;
}
fprintf(stderr,
"[agp] %d kB allocated with handle 0x%08x\n",
info->agpSize*1024, (unsigned)info->agpMemHandle);
"[gart] %d kB allocated with handle 0x%08x\n",
info->gartSize*1024, (unsigned)info->gartMemHandle);
if (drmAgpBind(ctx->drmFD,
info->agpMemHandle, info->agpOffset) < 0) {
fprintf(stderr, "[agp] Could not bind\n");
drmAgpFree(ctx->drmFD, info->agpMemHandle);
info->gartMemHandle, info->gartOffset) < 0) {
fprintf(stderr, "[gart] Could not bind\n");
drmAgpFree(ctx->drmFD, info->gartMemHandle);
drmAgpRelease(ctx->drmFD);
return 0;
}
/* Initialize the CP ring buffer data */
info->ringStart = info->agpOffset;
info->ringStart = info->gartOffset;
info->ringMapSize = info->ringSize*1024*1024 + DRM_PAGE_SIZE;
info->ringReadOffset = info->ringStart + info->ringMapSize;
@ -378,51 +378,51 @@ static int RADEONDRIAgpInit( const DRIDriverContext *ctx, RADEONInfoPtr info)
info->bufMapSize = info->bufSize*1024*1024;
/* Reserve the rest for AGP textures */
info->agpTexStart = info->bufStart + info->bufMapSize;
s = (info->agpSize*1024*1024 - info->agpTexStart);
info->gartTexStart = info->bufStart + info->bufMapSize;
s = (info->gartSize*1024*1024 - info->gartTexStart);
l = RADEONMinBits((s-1) / RADEON_NR_TEX_REGIONS);
if (l < RADEON_LOG_TEX_GRANULARITY) l = RADEON_LOG_TEX_GRANULARITY;
info->agpTexMapSize = (s >> l) << l;
info->log2AGPTexGran = l;
info->gartTexMapSize = (s >> l) << l;
info->log2GARTTexGran = l;
if (drmAddMap(ctx->drmFD, info->ringStart, info->ringMapSize,
DRM_AGP, DRM_READ_ONLY, &info->ringHandle) < 0) {
fprintf(stderr, "[agp] Could not add ring mapping\n");
fprintf(stderr, "[gart] Could not add ring mapping\n");
return 0;
}
fprintf(stderr, "[agp] ring handle = 0x%08lx\n", info->ringHandle);
fprintf(stderr, "[gart] ring handle = 0x%08lx\n", info->ringHandle);
if (drmAddMap(ctx->drmFD, info->ringReadOffset, info->ringReadMapSize,
DRM_AGP, DRM_READ_ONLY, &info->ringReadPtrHandle) < 0) {
fprintf(stderr,
"[agp] Could not add ring read ptr mapping\n");
"[gart] Could not add ring read ptr mapping\n");
return 0;
}
fprintf(stderr,
"[agp] ring read ptr handle = 0x%08lx\n",
"[gart] ring read ptr handle = 0x%08lx\n",
info->ringReadPtrHandle);
if (drmAddMap(ctx->drmFD, info->bufStart, info->bufMapSize,
DRM_AGP, 0, &info->bufHandle) < 0) {
fprintf(stderr,
"[agp] Could not add vertex/indirect buffers mapping\n");
"[gart] Could not add vertex/indirect buffers mapping\n");
return 0;
}
fprintf(stderr,
"[agp] vertex/indirect buffers handle = 0x%08lx\n",
"[gart] vertex/indirect buffers handle = 0x%08lx\n",
info->bufHandle);
if (drmAddMap(ctx->drmFD, info->agpTexStart, info->agpTexMapSize,
DRM_AGP, 0, &info->agpTexHandle) < 0) {
if (drmAddMap(ctx->drmFD, info->gartTexStart, info->gartTexMapSize,
DRM_AGP, 0, &info->gartTexHandle) < 0) {
fprintf(stderr,
"[agp] Could not add AGP texture map mapping\n");
"[gart] Could not add AGP texture map mapping\n");
return 0;
}
fprintf(stderr,
"[agp] AGP texture map handle = 0x%08lx\n",
info->agpTexHandle);
"[gart] AGP texture map handle = 0x%08lx\n",
info->gartTexHandle);
/* Initialize Radeon's AGP registers */
/* Ring buffer is at AGP offset 0 */
@ -463,7 +463,7 @@ static int RADEONDRIKernelInit( const DRIDriverContext *ctx,
drmInfo.sarea_priv_offset = sizeof(XF86DRISAREARec);
drmInfo.is_pci = 0;
drmInfo.cp_mode = RADEON_DEFAULT_CP_BM_MODE;
drmInfo.agp_size = info->agpSize*1024*1024;
drmInfo.gart_size = info->gartSize*1024*1024;
drmInfo.ring_size = info->ringSize*1024*1024;
drmInfo.usec_timeout = 1000;
drmInfo.fb_bpp = ctx->bpp;
@ -479,7 +479,7 @@ static int RADEONDRIKernelInit( const DRIDriverContext *ctx,
drmInfo.ring_offset = info->ringHandle;
drmInfo.ring_rptr_offset = info->ringReadPtrHandle;
drmInfo.buffers_offset = info->bufHandle;
drmInfo.agp_textures_offset = info->agpTexHandle;
drmInfo.gart_textures_offset = info->gartTexHandle;
ret = drmCommandWrite(ctx->drmFD, DRM_RADEON_CP_INIT, &drmInfo,
sizeof(drmRadeonInit));
@ -502,19 +502,19 @@ static void RADEONDRIAgpHeapInit(const DRIDriverContext *ctx,
{
drmRadeonMemInitHeap drmHeap;
/* Start up the simple memory manager for agp space */
drmHeap.region = RADEON_MEM_REGION_AGP;
/* Start up the simple memory manager for gart space */
drmHeap.region = RADEON_MEM_REGION_GART;
drmHeap.start = 0;
drmHeap.size = info->agpTexMapSize;
drmHeap.size = info->gartTexMapSize;
if (drmCommandWrite(ctx->drmFD, DRM_RADEON_INIT_HEAP,
&drmHeap, sizeof(drmHeap))) {
fprintf(stderr,
"[drm] Failed to initialized agp heap manager\n");
"[drm] Failed to initialized gart heap manager\n");
} else {
fprintf(stderr,
"[drm] Initialized kernel agp heap manager, %d\n",
info->agpTexMapSize);
"[drm] Initialized kernel gart heap manager, %d\n",
info->gartTexMapSize);
}
}
@ -640,13 +640,13 @@ static int RADEONMemoryInit( const DRIDriverContext *ctx, RADEONInfoPtr info )
info->frontPitch = ctx->shared.virtualWidth;
fprintf(stderr,
"Using %d MB AGP aperture\n", info->agpSize);
"Using %d MB AGP aperture\n", info->gartSize);
fprintf(stderr,
"Using %d MB for the ring buffer\n", info->ringSize);
fprintf(stderr,
"Using %d MB for vertex/indirect buffers\n", info->bufSize);
fprintf(stderr,
"Using %d MB for AGP textures\n", info->agpTexSize);
"Using %d MB for AGP textures\n", info->gartTexSize);
/* Front, back and depth buffers - everything else texture??
*/
@ -733,7 +733,7 @@ static int RADEONMemoryInit( const DRIDriverContext *ctx, RADEONInfoPtr info )
* Setups a RADEONDRIRec structure to be passed to radeon_dri.so for its
* initialization.
*/
static int RADEONScreenInit( const DRIDriverContext *ctx, RADEONInfoPtr info )
static int RADEONScreenInit( DRIDriverContext *ctx, RADEONInfoPtr info )
{
RADEONDRIPtr pRADEONDRI;
int err;
@ -883,7 +883,7 @@ static int RADEONScreenInit( const DRIDriverContext *ctx, RADEONInfoPtr info )
/* Initialize IRQ */
RADEONDRIIrqInit(ctx, info);
/* Initialize kernel agp memory manager */
/* Initialize kernel gart memory manager */
RADEONDRIAgpHeapInit(ctx, info);
/* Initialize the SAREA private data structure */
@ -919,7 +919,7 @@ static int RADEONScreenInit( const DRIDriverContext *ctx, RADEONInfoPtr info )
pRADEONDRI->depth = ctx->bpp; /* XXX: depth */
pRADEONDRI->bpp = ctx->bpp;
pRADEONDRI->IsPCI = 0;
pRADEONDRI->AGPMode = info->agpMode;
pRADEONDRI->AGPMode = info->gartMode;
pRADEONDRI->frontOffset = info->frontOffset;
pRADEONDRI->frontPitch = info->frontPitch;
pRADEONDRI->backOffset = info->backOffset;
@ -933,10 +933,10 @@ static int RADEONScreenInit( const DRIDriverContext *ctx, RADEONInfoPtr info )
pRADEONDRI->registerSize = info->registerSize;
pRADEONDRI->statusHandle = info->ringReadPtrHandle;
pRADEONDRI->statusSize = info->ringReadMapSize;
pRADEONDRI->agpTexHandle = info->agpTexHandle;
pRADEONDRI->agpTexMapSize = info->agpTexMapSize;
pRADEONDRI->log2AGPTexGran = info->log2AGPTexGran;
pRADEONDRI->agpTexOffset = info->agpTexStart;
pRADEONDRI->gartTexHandle = info->gartTexHandle;
pRADEONDRI->gartTexMapSize = info->gartTexMapSize;
pRADEONDRI->log2GARTTexGran = info->log2GARTTexGran;
pRADEONDRI->gartTexOffset = info->gartTexStart;
pRADEONDRI->sarea_priv_offset = sizeof(XF86DRISAREARec);
/* Don't release the lock now - let the VT switch handler do it. */
@ -1139,10 +1139,10 @@ static int radeonInitFBDev( DRIDriverContext *ctx )
ctx->driverPrivate = (void *)info;
info->agpFastWrite = RADEON_DEFAULT_AGP_FAST_WRITE;
info->agpMode = RADEON_DEFAULT_AGP_MODE;
info->agpSize = RADEON_DEFAULT_AGP_SIZE;
info->agpTexSize = RADEON_DEFAULT_AGP_TEX_SIZE;
info->gartFastWrite = RADEON_DEFAULT_AGP_FAST_WRITE;
info->gartMode = RADEON_DEFAULT_AGP_MODE;
info->gartSize = RADEON_DEFAULT_AGP_SIZE;
info->gartTexSize = RADEON_DEFAULT_AGP_TEX_SIZE;
info->bufSize = RADEON_DEFAULT_BUFFER_SIZE;
info->ringSize = RADEON_DEFAULT_RING_SIZE;

8
src/mesa/drivers/dri/radeon/server/radeon_dri.h
View file

@ -102,10 +102,10 @@ typedef struct {
* \name CP AGP Texture data
*/
/*@{*/
drmHandle agpTexHandle; /**< \brief AGP texture area map handle */
drmSize agpTexMapSize; /**< \brief AGP texture area map size */
int log2AGPTexGran; /**< \brief AGP texture granularity in log base 2 */
int agpTexOffset; /**< \brief AGP texture area offset in AGP space */
drmHandle gartTexHandle; /**< \brief AGP texture area map handle */
drmSize gartTexMapSize; /**< \brief AGP texture area map size */
int log2GARTTexGran; /**< \brief AGP texture granularity in log base 2 */
int gartTexOffset; /**< \brief AGP texture area offset in AGP space */
/*@}*/
unsigned int sarea_priv_offset; /**< \brief offset of the private SAREA data*/

110
src/mesa/drivers/dri/radeon/server/radeon_reg.h
View file

@ -1,4 +1,4 @@
/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/ati/radeon_reg.h,v 1.25 2003/02/07 18:08:59 martin Exp $ */
/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/ati/radeon_reg.h,v 1.30 2003/10/07 22:47:12 martin Exp $ */
/*
* Copyright 2000 ATI Technologies Inc., Markham, Ontario, and
* VA Linux Systems Inc., Fremont, California.
@ -66,6 +66,8 @@
# define RADEON_AGP_APER_SIZE_4MB (0x3f << 0)
# define RADEON_AGP_APER_SIZE_MASK (0x3f << 0)
#define RADEON_AGP_COMMAND 0x0f60 /* PCI */
#define RADEON_AGP_COMMAND_PCI_CONFIG 0x0060 /* offset in PCI config*/
# define RADEON_AGP_ENABLE (1<<8)
#define RADEON_AGP_PLL_CNTL 0x000b /* PLL */
#define RADEON_AGP_STATUS 0x0f5c /* PCI */
# define RADEON_AGP_1X_MODE 0x01
@ -232,6 +234,28 @@
# define RADEON_CONSTANT_COLOR_ZERO 0x00000000
#define RADEON_CRC_CMDFIFO_ADDR 0x0740
#define RADEON_CRC_CMDFIFO_DOUT 0x0744
#define RADEON_GRPH_BUFFER_CNTL 0x02f0
# define RADEON_GRPH_START_REQ_MASK (0x7f)
# define RADEON_GRPH_START_REQ_SHIFT 0
# define RADEON_GRPH_STOP_REQ_MASK (0x7f<<8)
# define RADEON_GRPH_STOP_REQ_SHIFT 8
# define RADEON_GRPH_CRITICAL_POINT_MASK (0x7f<<16)
# define RADEON_GRPH_CRITICAL_POINT_SHIFT 16
# define RADEON_GRPH_CRITICAL_CNTL (1<<28)
# define RADEON_GRPH_BUFFER_SIZE (1<<29)
# define RADEON_GRPH_CRITICAL_AT_SOF (1<<30)
# define RADEON_GRPH_STOP_CNTL (1<<31)
#define RADEON_GRPH2_BUFFER_CNTL 0x03f0
# define RADEON_GRPH2_START_REQ_MASK (0x7f)
# define RADEON_GRPH2_START_REQ_SHIFT 0
# define RADEON_GRPH2_STOP_REQ_MASK (0x7f<<8)
# define RADEON_GRPH2_STOP_REQ_SHIFT 8
# define RADEON_GRPH2_CRITICAL_POINT_MASK (0x7f<<16)
# define RADEON_GRPH2_CRITICAL_POINT_SHIFT 16
# define RADEON_GRPH2_CRITICAL_CNTL (1<<28)
# define RADEON_GRPH2_BUFFER_SIZE (1<<29)
# define RADEON_GRPH2_CRITICAL_AT_SOF (1<<30)
# define RADEON_GRPH2_STOP_CNTL (1<<31)
#define RADEON_CRTC_CRNT_FRAME 0x0214
#define RADEON_CRTC_EXT_CNTL 0x0054
# define RADEON_CRTC_VGA_XOVERSCAN (1 << 0)
@ -272,6 +296,9 @@
# define RADEON_CRTC2_CSYNC_EN (1 << 27)
# define RADEON_CRTC2_HSYNC_DIS (1 << 28)
# define RADEON_CRTC2_VSYNC_DIS (1 << 29)
#define RADEON_CRTC_MORE_CNTL 0x27c
# define RADEON_CRTC_H_CUTOFF_ACTIVE_EN (1<<4)
# define RADEON_CRTC_V_CUTOFF_ACTIVE_EN (1<<5)
#define RADEON_CRTC_GUI_TRIG_VLINE 0x0218
#define RADEON_CRTC_H_SYNC_STRT_WID 0x0204
# define RADEON_CRTC_H_SYNC_STRT_PIX (0x07 << 0)
@ -356,7 +383,10 @@
#define RADEON_DAC_CNTL 0x0058
# define RADEON_DAC_RANGE_CNTL (3 << 0)
# define RADEON_DAC_RANGE_CNTL_MASK 0x03
# define RADEON_DAC_BLANKING (1 << 2)
# define RADEON_DAC_CMP_EN (1 << 3)
# define RADEON_DAC_CMP_OUTPUT (1 << 7)
# define RADEON_DAC_8BIT_EN (1 << 8)
# define RADEON_DAC_VGA_ADR_EN (1 << 13)
# define RADEON_DAC_PDWN (1 << 15)
@ -365,6 +395,12 @@
# define RADEON_DAC2_DAC_CLK_SEL (1 << 0)
# define RADEON_DAC2_DAC2_CLK_SEL (1 << 1)
# define RADEON_DAC2_PALETTE_ACC_CTL (1 << 5)
#define RADEON_DAC_EXT_CNTL 0x0280
# define RADEON_DAC_FORCE_BLANK_OFF_EN (1 << 4)
# define RADEON_DAC_FORCE_DATA_EN (1 << 5)
# define RADEON_DAC_FORCE_DATA_SEL_MASK (3 << 6)
# define RADEON_DAC_FORCE_DATA_MASK 0x0003ff00
# define RADEON_DAC_FORCE_DATA_SHIFT 8
#define RADEON_TV_DAC_CNTL 0x088c
# define RADEON_TV_DAC_STD_MASK 0x0300
# define RADEON_TV_DAC_RDACPD (1 << 24)
@ -374,7 +410,9 @@
# define RADEON_CRT2_DISP1_SEL (1 << 5)
#define RADEON_DISP_OUTPUT_CNTL 0x0d64
# define RADEON_DISP_DAC_SOURCE_MASK 0x03
# define RADEON_DISP_DAC2_SOURCE_MASK 0x0c
# define RADEON_DISP_DAC_SOURCE_CRTC2 0x01
# define RADEON_DISP_DAC2_SOURCE_CRTC2 0x04
#define RADEON_DAC_CRC_SIG 0x02cc
#define RADEON_DAC_DATA 0x03c9 /* VGA */
#define RADEON_DAC_MASK 0x03c6 /* VGA */
@ -392,6 +430,23 @@
#define RADEON_DEVICE_ID 0x0f02 /* PCI */
#define RADEON_DISP_MISC_CNTL 0x0d00
# define RADEON_SOFT_RESET_GRPH_PP (1 << 0)
#define RADEON_DISP_MERGE_CNTL 0x0d60
# define RADEON_DISP_ALPHA_MODE_MASK 0x03
# define RADEON_DISP_ALPHA_MODE_KEY 0
# define RADEON_DISP_ALPHA_MODE_PER_PIXEL 1
# define RADEON_DISP_ALPHA_MODE_GLOBAL 2
# define RADEON_DISP_RGB_OFFSET_EN (1<<8)
# define RADEON_DISP_GRPH_ALPHA_MASK (0xff << 16)
# define RADEON_DISP_OV0_ALPHA_MASK (0xff << 24)
# define RADEON_DISP_LIN_TRANS_BYPASS (0x01 << 9)
#define RADEON_DISP2_MERGE_CNTL 0x0d68
# define RADEON_DISP2_RGB_OFFSET_EN (1<<8)
#define RADEON_DISP_LIN_TRANS_GRPH_A 0x0d80
#define RADEON_DISP_LIN_TRANS_GRPH_B 0x0d84
#define RADEON_DISP_LIN_TRANS_GRPH_C 0x0d88
#define RADEON_DISP_LIN_TRANS_GRPH_D 0x0d8c
#define RADEON_DISP_LIN_TRANS_GRPH_E 0x0d90
#define RADEON_DISP_LIN_TRANS_GRPH_F 0x0d98
#define RADEON_DP_BRUSH_BKGD_CLR 0x1478
#define RADEON_DP_BRUSH_FRGD_CLR 0x147c
#define RADEON_DP_CNTL 0x16c0
@ -582,7 +637,10 @@
# define RADEON_FP2_BLANK_EN (1 << 1)
# define RADEON_FP2_ON (1 << 2)
# define RADEON_FP2_PANEL_FORMAT (1 << 3)
# define RADEON_FP2_SEL_CRTC2 (1 << 13)
# define RADEON_FP2_SOURCE_SEL_MASK (3 << 10)
# define RADEON_FP2_SOURCE_SEL_CRTC2 (1 << 10)
# define RADEON_FP2_SRC_SEL_MASK (3 << 13)
# define RADEON_FP2_SRC_SEL_CRTC2 (1 << 13)
# define RADEON_FP2_FP_POL (1 << 16)
# define RADEON_FP2_LP_POL (1 << 17)
# define RADEON_FP2_SCK_POL (1 << 18)
@ -590,6 +648,8 @@
# define RADEON_FP2_PAD_FLOP_EN (1 << 22)
# define RADEON_FP2_CRC_EN (1 << 23)
# define RADEON_FP2_CRC_READ_EN (1 << 24)
# define RADEON_FP2_DV0_EN (1 << 25)
# define RADEON_FP2_DV0_RATE_SEL_SDR (1 << 26)
#define RADEON_FP_H_SYNC_STRT_WID 0x02c4
#define RADEON_FP_H2_SYNC_STRT_WID 0x03c4
#define RADEON_FP_HORZ_STRETCH 0x028c
@ -697,6 +757,10 @@
#define RADEON_MAX_LATENCY 0x0f3f /* PCI */
#define RADEON_MC_AGP_LOCATION 0x014c
#define RADEON_MC_FB_LOCATION 0x0148
#define RADEON_DISPLAY_BASE_ADDR 0x23c
#define RADEON_DISPLAY2_BASE_ADDR 0x33c
#define RADEON_OV0_BASE_ADDR 0x43c
#define RADEON_NB_TOM 0x15c
#define RADEON_MCLK_CNTL 0x0012 /* PLL */
# define RADEON_FORCEON_MCLKA (1 << 16)
# define RADEON_FORCEON_MCLKB (1 << 17)
@ -711,6 +775,12 @@
#define RADEON_MEM_ADDR_CONFIG 0x0148
#define RADEON_MEM_BASE 0x0f10 /* PCI */
#define RADEON_MEM_CNTL 0x0140
# define RADEON_MEM_NUM_CHANNELS_MASK 0x01
# define RADEON_MEM_USE_B_CH_ONLY (1<<1)
# define RV100_HALF_MODE (1<<3)
# define R300_MEM_NUM_CHANNELS_MASK 0x03
# define R300_MEM_USE_CD_CH_ONLY (1<<2)
#define RADEON_MEM_TIMING_CNTL 0x0144 /* EXT_MEM_CNTL */
#define RADEON_MEM_INIT_LAT_TIMER 0x0154
#define RADEON_MEM_INTF_CNTL 0x014c
#define RADEON_MEM_SDRAM_MODE_REG 0x0158
@ -723,7 +793,13 @@
#define RADEON_MPLL_CNTL 0x000e /* PLL */
#define RADEON_MPP_TB_CONFIG 0x01c0 /* ? */
#define RADEON_MPP_GP_CONFIG 0x01c8 /* ? */
#define R300_MC_IND_INDEX 0x01f8
# define R300_MC_IND_ADDR_MASK 0x3f
#define R300_MC_IND_DATA 0x01fc
#define R300_MC_READ_CNTL_AB 0x017c
# define R300_MEM_RBS_POSITION_A_MASK 0x03
#define R300_MC_READ_CNTL_CD_mcind 0x24
# define R300_MEM_RBS_POSITION_C_MASK 0x03
#define RADEON_N_VIF_COUNT 0x0248
@ -879,7 +955,7 @@
# define RADEON_P2PLL_REF_DIV_MASK 0x03ff
# define RADEON_P2PLL_ATOMIC_UPDATE_R (1 << 15) /* same as _W */
# define RADEON_P2PLL_ATOMIC_UPDATE_W (1 << 15) /* same as _R */
# define R300_PPLL_REF_DIV_ACC_MASK (0x3ff < 18)
# define R300_PPLL_REF_DIV_ACC_MASK (0x3ff << 18)
# define R300_PPLL_REF_DIV_ACC_SHIFT 18
#define RADEON_PALETTE_DATA 0x00b4
#define RADEON_PALETTE_30_DATA 0x00b8
@ -891,6 +967,11 @@
# define RADEON_PIX2CLK_SRC_SEL_PSCANCLK 0x01
# define RADEON_PIX2CLK_SRC_SEL_BYTECLK 0x02
# define RADEON_PIX2CLK_SRC_SEL_P2PLLCLK 0x03
# define RADEON_PIX2CLK_ALWAYS_ONb (1<<6)
# define RADEON_PIX2CLK_DAC_ALWAYS_ONb (1<<7)
# define RADEON_PIXCLK_TV_SRC_SEL (1 << 8)
# define RADEON_PIXCLK_LVDS_ALWAYS_ONb (1 << 14)
# define RADEON_PIXCLK_TMDS_ALWAYS_ONb (1 << 15)
#define RADEON_PLANE_3D_MASK_C 0x1d44
#define RADEON_PLL_TEST_CNTL 0x0013 /* PLL */
#define RADEON_PMI_CAP_ID 0x0f5c /* PCI */
@ -1013,6 +1094,9 @@
#define RADEON_TEST_DEBUG_MUX 0x0124
#define RADEON_TEST_DEBUG_OUT 0x012c
#define RADEON_TMDS_PLL_CNTL 0x02a8
#define RADEON_TMDS_TRANSMITTER_CNTL 0x02a4
# define RADEON_TMDS_TRANSMITTER_PLLEN 1
# define RADEON_TMDS_TRANSMITTER_PLLRST 2
#define RADEON_TRAIL_BRES_DEC 0x1614
#define RADEON_TRAIL_BRES_ERR 0x160c
#define RADEON_TRAIL_BRES_INC 0x1610
@ -1025,6 +1109,9 @@
# define RADEON_VCLK_SRC_SEL_PSCANCLK 0x01
# define RADEON_VCLK_SRC_SEL_BYTECLK 0x02
# define RADEON_VCLK_SRC_SEL_PPLLCLK 0x03
# define RADEON_PIXCLK_ALWAYS_ONb (1<<6)
# define RADEON_PIXCLK_DAC_ALWAYS_ONb (1<<7)
#define RADEON_VENDOR_ID 0x0f00 /* PCI */
#define RADEON_VGA_DDA_CONFIG 0x02e8
#define RADEON_VGA_DDA_ON_OFF 0x02ec
@ -1878,12 +1965,11 @@
#define RADEON_AIC_CNTL 0x01d0
# define RADEON_PCIGART_TRANSLATE_EN (1 << 0)
#define RADEON_AIC_LO_ADDR 0x01dc
/* Constants */
#define RADEON_AGP_TEX_OFFSET 0x02000000
#define RADEON_LAST_FRAME_REG RADEON_GUI_SCRATCH_REG0
#define RADEON_LAST_CLEAR_REG RADEON_GUI_SCRATCH_REG2
@ -2012,4 +2098,16 @@
#define RADEON_SS_HORZ_GUARD_DISCARD_ADJ_ADDR 51
#define RADEON_SS_SHININESS 60
#define RADEON_TV_MASTER_CNTL 0x0800
# define RADEON_TVCLK_ALWAYS_ONb (1 << 30)
#define RADEON_TV_DAC_CNTL 0x088c
# define RADEON_TV_DAC_CMPOUT (1 << 5)
#define RADEON_TV_PRE_DAC_MUX_CNTL 0x0888
# define RADEON_Y_RED_EN (1 << 0)
# define RADEON_C_GRN_EN (1 << 1)
# define RADEON_CMP_BLU_EN (1 << 2)
# define RADEON_RED_MX_FORCE_DAC_DATA (6 << 4)
# define RADEON_GRN_MX_FORCE_DAC_DATA (6 << 8)
# define RADEON_BLU_MX_FORCE_DAC_DATA (6 << 12)
# define RADEON_TV_FORCE_DAC_DATA_SHIFT 16
#endif

171
src/mesa/drivers/dri/radeon/server/radeon_sarea.h
View file

@ -1,11 +1,4 @@
/**
* \file server/radeon_sarea.h
* \brief SAREA definition.
*
* \author Kevin E. Martin <martin@xfree86.org>
* \author Gareth Hughes <gareth@valinux.com>
*/
/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/ati/radeon_sarea.h,v 1.5 2002/10/30 12:52:14 alanh Exp $ */
/*
* Copyright 2000 ATI Technologies Inc., Markham, Ontario,
* VA Linux Systems Inc., Fremont, California.
@ -34,7 +27,12 @@
* DEALINGS IN THE SOFTWARE.
*/
/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/ati/radeon_sarea.h,v 1.4 2002/04/24 16:20:41 martin Exp $ */
/*
* Authors:
* Kevin E. Martin <martin@xfree86.org>
* Gareth Hughes <gareth@valinux.com>
*
*/
#ifndef _RADEON_SAREA_H_
#define _RADEON_SAREA_H_
@ -94,11 +92,11 @@
/* Keep these small for testing */
#define RADEON_NR_SAREA_CLIPRECTS 12
/* There are 2 heaps (local/AGP). Each region within a heap is a
/* There are 2 heaps (local/GART). Each region within a heap is a
* minimum of 64k, and there are at most 64 of them per heap.
*/
#define RADEON_CARD_HEAP 0
#define RADEON_AGP_HEAP 1
#define RADEON_GART_HEAP 1
#define RADEON_NR_TEX_HEAPS 2
#define RADEON_NR_TEX_REGIONS 64
#define RADEON_LOG_TEX_GRANULARITY 16
@ -115,10 +113,6 @@
#endif /* __RADEON_SAREA_DEFINES__ */
/**
* \brief Color register format.
*/
typedef struct {
unsigned int red;
unsigned int green;
@ -126,15 +120,8 @@ typedef struct {
unsigned int alpha;
} radeon_color_regs_t;
/**
* \brief Context registers.
*/
typedef struct {
/**
* \name Context state
*/
/*@{*/
/* Context state */
unsigned int pp_misc;
unsigned int pp_fog_color;
unsigned int re_solid_color;
@ -149,76 +136,44 @@ typedef struct {
unsigned int re_width_height;
unsigned int rb3d_colorpitch;
unsigned int se_cntl;
/*@}*/
/**
* \name Vertex format state
*/
/*@{*/
/* Vertex format state */
unsigned int se_coord_fmt;
/*@}*/
/**
* \name Line state
*/
/*@{*/
/* Line state */
unsigned int re_line_pattern;
unsigned int re_line_state;
unsigned int se_line_width;
/*@}*/
/**
* \name Bumpmap state
*/
/*@{*/
/* Bumpmap state */
unsigned int pp_lum_matrix;
unsigned int pp_rot_matrix_0;
unsigned int pp_rot_matrix_1;
/*@}*/
/**
* \name Mask state
*/
/*@{*/
/* Mask state */
unsigned int rb3d_stencilrefmask;
unsigned int rb3d_ropcntl;
unsigned int rb3d_planemask;
/*@}*/
/**
* \name Viewport state
*/
/*@{*/
/* Viewport state */
unsigned int se_vport_xscale;
unsigned int se_vport_xoffset;
unsigned int se_vport_yscale;
unsigned int se_vport_yoffset;
unsigned int se_vport_zscale;
unsigned int se_vport_zoffset;
/*@}*/
/**
* \name Setup state
*/
/*@{*/
/* Setup state */
unsigned int se_cntl_status;
/*@}*/
/**
* \name Misc state
*/
/*@{*/
/* Misc state */
unsigned int re_top_left;
unsigned int re_misc;
/*@}*/
} radeon_context_regs_t;
/**
* \brief Setup registers for each texture unit
*/
/* Setup registers for each texture unit */
typedef struct {
unsigned int pp_txfilter;
unsigned int pp_txformat;
@ -229,82 +184,48 @@ typedef struct {
unsigned int pp_border_color;
} radeon_texture_regs_t;
/**
* \brief Maintain an LRU of contiguous regions of texture space.
*
* If you think you own a region of texture memory, and it has an age different
* to the one you set, then you are mistaken and it has been stolen by another
* client. If global RADEONSAREAPriv::texAge hasn't changed, there is no need to walk the list.
*
* These regions can be used as a proxy for the fine-grained texture
* information of other clients - by maintaining them in the same LRU which is
* used to age their own textures, clients have an approximate LRU for the
* whole of global texture space, and can make informed decisions as to which
* areas to kick out. There is no need to choose whether to kick out your own
* texture or someone else's - simply eject them all in LRU order.
*
* \sa RADEONSAREAPriv::texList.
*/
typedef struct {
unsigned char next; /**< \brief indices to form a circular LRU */
unsigned char prev; /**< \brief indices to form a circular LRU */
unsigned char in_use; /**< \brief owned by a client, or free? */
int age; /**< \brief tracked by clients to update local LRU's */
} radeon_tex_region_t;
/**
* \brief Private SAREA definition
*
* The channel for communication of state information to the kernel
/* The channel for communication of state information to the kernel
* on firing a vertex buffer.
*/
typedef struct {
radeon_context_regs_t ContextState; /** \brief Context registers */
radeon_context_regs_t ContextState;
radeon_texture_regs_t TexState[RADEON_MAX_TEXTURE_UNITS];
/**< \brief Texture registers */
unsigned int dirty;
unsigned int vertsize; /**< \brief vertex size */
unsigned int vc_format; /**< \brief vertex format */
unsigned int vertsize;
unsigned int vc_format;
/**
* \name Cliprects
*
* The current cliprects, or a subset thereof.
*/
/*@{*/
/* The current cliprects, or a subset thereof */
XF86DRIClipRectRec boxes[RADEON_NR_SAREA_CLIPRECTS];
/**< \brief cliprects */
unsigned int nbox; /**< \brief number of cliprects */
/*@}*/
unsigned int nbox;
/**
* \name Counters
*
* Counters for throttling rendering of clients.
*/
/*@{*/
unsigned int last_frame; /**< \brief last emmited frame */
/* Counters for throttling of rendering clients */
unsigned int last_frame;
unsigned int last_dispatch;
unsigned int last_clear; /**< \brief last emmited clear */
/*@}*/
unsigned int last_clear;
/**
* \name LRU
*/
/*@{*/
/** \brief Texture regions.
* Last element is sentinal
/* Maintain an LRU of contiguous regions of texture space. If you
* think you own a region of texture memory, and it has an age
* different to the one you set, then you are mistaken and it has
* been stolen by another client. If global texAge hasn't changed,
* there is no need to walk the list.
*
* These regions can be used as a proxy for the fine-grained texture
* information of other clients - by maintaining them in the same
* lru which is used to age their own textures, clients have an
* approximate lru for the whole of global texture space, and can
* make informed decisions as to which areas to kick out. There is
* no need to choose whether to kick out your own texture or someone
* else's - simply eject them all in LRU order.
*/
/* Last elt is sentinal */
drmTextureRegion texList[RADEON_NR_TEX_HEAPS][RADEON_NR_TEX_REGIONS+1];
/** \brief last time texture was uploaded */
/* last time texture was uploaded */
unsigned int texAge[RADEON_NR_TEX_HEAPS];
/*@}*/
int ctxOwner; /**< \brief last context to upload state */
int pfAllowPageFlip; /**< \brief set by the 2d driver, read by the client */
int pfCurrentPage; /**< \brief set by kernel, read by others */
int crtc2_base; /**< \brief for pageflipping with CloneMode */
int ctxOwner; /* last context to upload state */
int pfAllowPageFlip; /* set by the 2d driver, read by the client */
int pfCurrentPage; /* set by kernel, read by others */
int crtc2_base; /* for pageflipping with CloneMode */
} RADEONSAREAPriv, *RADEONSAREAPrivPtr;
#endif