#if defined(FX)
#include "fxdrv.h"
+#include "drivers/common/driverfuncs.h"
+
#ifndef TDFX_DEBUG
int TDFX_DEBUG = (0
/* | VERBOSE_VARRAY */
}
-void * GLAPIENTRY fxMesaGetCurrentContext (void)
+fxMesaContext GLAPIENTRY fxMesaGetCurrentContext (void)
{
- GET_CURRENT_CONTEXT(ctx);
- return ctx;
+ return fxMesaCurrentCtx;
}
static GrScreenResolution_t fxBestResolution (int width, int height)
{
- static int resolutions[][5] = {
-#if 1 /* Voodoo^2 can't fullscreen these, because of Glide */
- { 320, 200, GR_RESOLUTION_320x200 },
- { 320, 240, GR_RESOLUTION_320x240 },
-#endif
- { 512, 384, GR_RESOLUTION_512x384 },
- { 640, 400, GR_RESOLUTION_640x400 },
- { 640, 480, GR_RESOLUTION_640x480 },
- { 800, 600, GR_RESOLUTION_800x600 },
- {1024, 768, GR_RESOLUTION_1024x768 },
- {1280, 1024, GR_RESOLUTION_1280x1024},
- {1600, 1200, GR_RESOLUTION_1600x1200},
+ static int resolutions[][3] = {
+ { GR_RESOLUTION_320x200, 320, 200 },
+ { GR_RESOLUTION_320x240, 320, 240 },
+ { GR_RESOLUTION_400x256, 400, 256 },
+ { GR_RESOLUTION_512x384, 512, 384 },
+ { GR_RESOLUTION_640x200, 640, 200 },
+ { GR_RESOLUTION_640x350, 640, 350 },
+ { GR_RESOLUTION_640x400, 640, 400 },
+ { GR_RESOLUTION_640x480, 640, 480 },
+ { GR_RESOLUTION_800x600, 800, 600 },
+ { GR_RESOLUTION_960x720, 960, 720 },
+ { GR_RESOLUTION_856x480, 856, 480 },
+ { GR_RESOLUTION_512x256, 512, 256 },
+ { GR_RESOLUTION_1024x768, 1024, 768 },
+ { GR_RESOLUTION_1280x1024, 1280, 1024 },
+ { GR_RESOLUTION_1600x1200, 1600, 1200 },
+ { GR_RESOLUTION_400x300, 400, 300 },
+ { GR_RESOLUTION_1152x864, 1152, 864 },
+ { GR_RESOLUTION_1280x960, 1280, 960 },
+ { GR_RESOLUTION_1600x1024, 1600, 1024 },
+ { GR_RESOLUTION_1792x1344, 1792, 1344 },
+ { GR_RESOLUTION_1856x1392, 1856, 1392 },
+ { GR_RESOLUTION_1920x1440, 1920, 1440 },
+ { GR_RESOLUTION_2048x1536, 2048, 1536 },
+ { GR_RESOLUTION_2048x2048, 2048, 2048 }
};
- int i, NUM_RESOLUTIONS = sizeof(resolutions) / sizeof(resolutions[0]);
- int lastvalidres = 4; /* set default to GR_RESOLUTION_640x480 */
+ int i, size;
+ int lastvalidres = GR_RESOLUTION_640x480;
int min = 2048 * 2048; /* max is GR_RESOLUTION_2048x2048 */
-
- for (i = 0; i < NUM_RESOLUTIONS; i++) {
- if ((width <= resolutions[i][0]) && (height <= resolutions[i][1])) {
- if (min > (resolutions[i][0] * resolutions[i][1])) {
- min = resolutions[i][0] * resolutions[i][1];
- lastvalidres = i;
+ GrResolution resTemplate = {
+ GR_QUERY_ANY,
+ GR_QUERY_ANY,
+ 2 /*GR_QUERY_ANY */,
+ GR_QUERY_ANY
+ };
+ GrResolution *presSupported;
+
+ fxQueryHardware();
+
+ size = grQueryResolutions(&resTemplate, NULL);
+ presSupported = malloc(size);
+
+ size /= sizeof(GrResolution);
+ grQueryResolutions(&resTemplate, presSupported);
+
+ for (i = 0; i < size; i++) {
+ int r = presSupported[i].resolution;
+ if ((width <= resolutions[r][1]) && (height <= resolutions[r][2])) {
+ if (min > (resolutions[r][1] * resolutions[r][2])) {
+ min = resolutions[r][1] * resolutions[r][2];
+ lastvalidres = r;
}
}
}
- return resolutions[lastvalidres][2];
+ free(presSupported);
+
+ return resolutions[lastvalidres][0];
}
{
fxMesaContext fxMesa = NULL;
GLcontext *ctx = NULL, *shareCtx = NULL;
+ struct dd_function_table functions;
int i;
const char *str;
- int sliaa, numSLI, samplesPerChip, tmuRam, fbRam;
+ int sliaa, numSLI, samplesPerChip;
struct SstCard_St *voodoo;
struct tdfx_glide *Glide;
GLuint redBits, greenBits, blueBits, alphaBits;
GrPixelFormat_t pixFmt;
- GLboolean useBGR;
-
if (TDFX_DEBUG & VERBOSE_DRIVER) {
fprintf(stderr, "fxMesaCreateContext(...)\n");
}
break;
/* XXX ugly hack here for sharing display lists */
case FXMESA_SHARE_CONTEXT:
- {
- const void *vPtr = &attribList[++i];
- GLcontext **ctx = (GLcontext **)vPtr;
- shareCtx = *ctx;
- }
+ shareCtx = (GLcontext *)attribList[++i];
break;
default:
fprintf(stderr, "fxMesaCreateContext: ERROR: wrong parameter (%d) passed\n", attribList[i]);
Glide->txMipQuantize &&
Glide->txPalToNcc && !getenv("MESA_FX_IGNORE_TEXUS2");
- /*
- * Pixel tables are used during pixel read-back
- * Either initialize them for RGB or BGR order;
- * However, 32bit capable cards have the right order.
- * As a consequence, 32bit read-back is not swizzled!
- * Also determine if we need vertex snapping.
- */
- /* number of SLI units and AA Samples per chip */
+ /* Determine if we need vertex swapping, RGB order and SLI/AA */
sliaa = 0;
- switch (voodoo->type) {
+ switch (fxMesa->type) {
case GR_SSTTYPE_VOODOO:
+ case GR_SSTTYPE_SST96:
case GR_SSTTYPE_Banshee:
- useBGR = GL_TRUE;
+ fxMesa->bgrOrder = GL_TRUE;
fxMesa->snapVertices = GL_TRUE;
break;
case GR_SSTTYPE_Voodoo2:
- useBGR = GL_TRUE;
+ fxMesa->bgrOrder = GL_TRUE;
fxMesa->snapVertices = GL_FALSE;
break;
case GR_SSTTYPE_Voodoo4:
case GR_SSTTYPE_Voodoo5:
+ /* number of SLI units and AA Samples per chip */
if ((str = Glide->grGetRegistryOrEnvironmentStringExt("SSTH3_SLI_AA_CONFIGURATION")) != NULL) {
sliaa = atoi(str);
}
case GR_SSTTYPE_Voodoo3:
default:
- useBGR = GL_FALSE;
+ fxMesa->bgrOrder = GL_FALSE;
fxMesa->snapVertices = GL_FALSE;
break;
}
pixFmt = GR_PIXFMT_RGB_565;
}
break;
+ case 24:
+ fxMesa->colDepth = 32;
case 32:
redBits = 8;
greenBits = 8;
goto errorhandler;
}
- /* Not that it matters, but tmuRam and fbRam change after grSstWinOpen. */
- tmuRam = voodoo->tmuConfig[GR_TMU0].tmuRam;
- fbRam = voodoo->fbRam;
- BEGIN_BOARD_LOCK();
- {
- FxI32 result;
- grGet(GR_MEMORY_TMU, 4, &result);
- tmuRam = result / (1024 * 1024);
- grGet(GR_MEMORY_FB, 4, &result);
- fbRam = result / (1024 * 1024);
- }
- END_BOARD_LOCK();
-
- sprintf(fxMesa->rendererString, "Mesa %s v0.60 %s %dMB FB, %dMB TM, %d TMU, %s",
- grGetString(GR_RENDERER),
- grGetString(GR_HARDWARE),
- fbRam,
- tmuRam * voodoo->nTexelfx,
- voodoo->nTexelfx,
- (voodoo->numChips > 1) ? "SLI" : "NOSLI");
-
- fxMesa->bgrOrder = useBGR;
-
/* screen */
fxMesa->screen_width = FX_grSstScreenWidth();
fxMesa->screen_height = FX_grSstScreenHeight();
fxMesa->clipMaxY = fxMesa->height;
if (fxMesa->verbose) {
- char buf[80];
-
- strcpy(buf, grGetString(GR_VERSION));
- fprintf(stderr, "Voodoo Using Glide %s\n", buf);
- fprintf(stderr, "Voodoo Number of boards: %d\n", glbHWConfig.num_sst);
- fprintf(stderr, "Voodoo Number of TMUs: %d\n", voodoo->nTexelfx);
- fprintf(stderr, "Voodoo fbRam: %d\n", voodoo->fbRam);
- fprintf(stderr, "Voodoo fbiRev: %d\n", voodoo->fbiRev);
- fprintf(stderr, "Voodoo chips detected: %d\n", voodoo->numChips);
- fprintf(stderr, "Voodoo pixel order = %s, vertex snapping = %d\n",
- useBGR ? "BGR" : "RGB",
- fxMesa->snapVertices);
- fprintf(stderr, "Voodoo screen: %dx%d:%d\n",
- fxMesa->screen_width, fxMesa->screen_height, colDepth);
+ FxI32 tmuRam, fbRam;
+
+ /* Not that it matters, but tmuRam and fbRam change after grSstWinOpen. */
+ tmuRam = voodoo->tmuConfig[GR_TMU0].tmuRam;
+ fbRam = voodoo->fbRam;
+ BEGIN_BOARD_LOCK();
+ grGet(GR_MEMORY_TMU, 4, &tmuRam);
+ grGet(GR_MEMORY_FB, 4, &fbRam);
+ END_BOARD_LOCK();
+
+ fprintf(stderr, "Voodoo Using Glide %s\n", grGetString(GR_VERSION));
+ fprintf(stderr, "Voodoo Board: %d/%d, %s, %d GPU\n",
+ fxMesa->board + 1,
+ glbHWConfig.num_sst,
+ grGetString(GR_HARDWARE),
+ voodoo->numChips);
+ fprintf(stderr, "Voodoo Memory: FB = %ld, TM = %d x %ld\n",
+ fbRam,
+ voodoo->nTexelfx,
+ tmuRam);
+ fprintf(stderr, "Voodoo Screen: %dx%d:%d %s, %svertex snapping\n",
+ fxMesa->screen_width,
+ fxMesa->screen_height,
+ colDepth,
+ fxMesa->bgrOrder ? "BGR" : "RGB",
+ fxMesa->snapVertices ? "" : "no ");
}
+ sprintf(fxMesa->rendererString, "Mesa %s v0.61 %s%s",
+ grGetString(GR_RENDERER),
+ grGetString(GR_HARDWARE),
+ ((fxMesa->type < GR_SSTTYPE_Voodoo4) && (voodoo->numChips > 1)) ? " SLI" : "");
+
fxMesa->glVis = _mesa_create_visual(GL_TRUE, /* RGB mode */
doubleBuffer,
GL_FALSE, /* stereo */
goto errorhandler;
}
- ctx = fxMesa->glCtx = _mesa_create_context(fxMesa->glVis,
- shareCtx,
- (void *) fxMesa, GL_TRUE);
+ _mesa_init_driver_functions(&functions);
+ ctx = fxMesa->glCtx = _mesa_create_context(fxMesa->glVis, shareCtx,
+ &functions, (void *) fxMesa);
if (!ctx) {
str = "_mesa_create_context";
goto errorhandler;
/* install signal handlers */
#if defined(__linux__)
/* Only install if environment var. is not set. */
- if (fxMesa->glCtx->CatchSignals && !getenv("MESA_FX_NO_SIGNALS")) {
+ if (!getenv("MESA_FX_NO_SIGNALS")) {
signal(SIGINT, cleangraphics_handler);
signal(SIGHUP, cleangraphics_handler);
signal(SIGPIPE, cleangraphics_handler);
fxMesa->stats.swapBuffer = 1;
fprintf(stderr, "Textures Stats:\n");
- fprintf(stderr, " Free texture memory on TMU0: %d:\n",
+ fprintf(stderr, " Free texture memory on TMU0: %d\n",
fxMesa->freeTexMem[FX_TMU0]);
if (fxMesa->haveTwoTMUs)
- fprintf(stderr, " Free texture memory on TMU1: %d:\n",
+ fprintf(stderr, " Free texture memory on TMU1: %d\n",
fxMesa->freeTexMem[FX_TMU1]);
fprintf(stderr, " # request to TMM to upload a texture objects: %u\n",
fxMesa->stats.reqTexUpload);
glbTotNumCtx--;
+ if (!glbTotNumCtx && getenv("MESA_FX_INFO")) {
+ GrSstPerfStats_t st;
+
+ FX_grSstPerfStats(&st);
+
+ fprintf(stderr, "Pixels Stats:\n");
+ fprintf(stderr, " # pixels processed (minus buffer clears): %u\n",
+ (unsigned) st.pixelsIn);
+ fprintf(stderr, " # pixels not drawn due to chroma key test failure: %u\n",
+ (unsigned) st.chromaFail);
+ fprintf(stderr, " # pixels not drawn due to depth test failure: %u\n",
+ (unsigned) st.zFuncFail);
+ fprintf(stderr,
+ " # pixels not drawn due to alpha test failure: %u\n",
+ (unsigned) st.aFuncFail);
+ fprintf(stderr, " # pixels drawn (including buffer clears and LFB writes): %u\n",
+ (unsigned) st.pixelsOut);
+ }
+
+ /* [dBorca]
+ * close the hardware first, so we can debug
+ * atexit problems (memory leaks, etc).
+ * NB: fxDDDestroyFxMesaContext must be called
+ * before _mesa_destroy_context; which must be
+ * called before fxTMClose!
+ */
+ grSstWinClose(fxMesa->glideContext);
+ fxCloseHardware();
+
fxDDDestroyFxMesaContext(fxMesa);
_mesa_destroy_visual(fxMesa->glVis);
_mesa_destroy_context(fxMesa->glCtx);
_mesa_destroy_framebuffer(fxMesa->glBuffer);
-
- grSstWinClose(fxMesa->glideContext);
- fxCloseHardware();
+ fxTMClose(fxMesa);
FREE(fxMesa);
grBufferSwap(fxMesaCurrentCtx->swapInterval);
+#if 0
/*
* Don't allow swap buffer commands to build up!
*/
in order to enable this option) */
/* usleep(10000); */
;
+#endif
fxMesaCurrentCtx->stats.swapBuffer++;
}
fxCloseHardware(void)
{
if (glbGlideInitialized) {
- if (fxMesaCurrentCtx && fxMesaCurrentCtx->verbose) {
- GrSstPerfStats_t st;
-
- FX_grSstPerfStats(&st);
- fprintf(stderr, "Pixels Stats:\n");
- fprintf(stderr, " # pixels processed (minus buffer clears): %u\n",
- (unsigned) st.pixelsIn);
- fprintf(stderr,
- " # pixels not drawn due to chroma key test failure: %u\n",
- (unsigned) st.chromaFail);
- fprintf(stderr,
- " # pixels not drawn due to depth test failure: %u\n",
- (unsigned) st.zFuncFail);
- fprintf(stderr,
- " # pixels not drawn due to alpha test failure: %u\n",
- (unsigned) st.aFuncFail);
- fprintf(stderr,
- " # pixels drawn (including buffer clears and LFB writes): %u\n",
- (unsigned) st.pixelsOut);
- }
-
if (glbTotNumCtx == 0) {
grGlideShutdown();
glbGlideInitialized = 0;
projects / mesa.git / blobdiff