[sdl_omap.git] / src / video / ps2gs / SDL_gsvideo.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

/* Framebuffer console based SDL video driver implementation.
*/

#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mman.h>

#include "SDL_video.h"
#include "SDL_mouse.h"
#include "../SDL_sysvideo.h"
#include "../SDL_pixels_c.h"
#include "../../events/SDL_events_c.h"
#include "../SDL_cursor_c.h"
#include "SDL_gsvideo.h"
#include "SDL_gsmouse_c.h"
#include "SDL_gsevents_c.h"
#include "SDL_gsyuv_c.h"


/* Initialization/Query functions */
static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat);
static SDL_Rect **GS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
static SDL_Surface *GS_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
static void GS_VideoQuit(_THIS);

/* Hardware surface functions */
static int GS_AllocHWSurface(_THIS, SDL_Surface *surface);
static int GS_LockHWSurface(_THIS, SDL_Surface *surface);
static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface);
static void GS_FreeHWSurface(_THIS, SDL_Surface *surface);

/* GS driver bootstrap functions */

static int GS_Available(void)
{
	int console, memory;

	console = open(PS2_DEV_GS, O_RDWR, 0);
	if ( console >= 0 ) {
		close(console);
	}
	memory = open(PS2_DEV_MEM, O_RDWR, 0);
	if ( memory >= 0 ) {
		close(memory);
	}
	return((console >= 0) && (memory >= 0));
}

static void GS_DeleteDevice(SDL_VideoDevice *device)
{
	SDL_free(device->hidden);
	SDL_free(device);
}

static SDL_VideoDevice *GS_CreateDevice(int devindex)
{
	SDL_VideoDevice *this;

	/* Initialize all variables that we clean on shutdown */
	this = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
	if ( this ) {
		SDL_memset(this, 0, (sizeof *this));
		this->hidden = (struct SDL_PrivateVideoData *)
				SDL_malloc((sizeof *this->hidden));
	}
	if ( (this == NULL) || (this->hidden == NULL) ) {
		SDL_OutOfMemory();
		if ( this ) {
			SDL_free(this);
		}
		return(0);
	}
	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
	mouse_fd = -1;
	keyboard_fd = -1;

	/* Set the function pointers */
	this->VideoInit = GS_VideoInit;
	this->ListModes = GS_ListModes;
	this->SetVideoMode = GS_SetVideoMode;
	this->CreateYUVOverlay = GS_CreateYUVOverlay;
	this->SetColors = GS_SetColors;
	this->UpdateRects = NULL;
	this->VideoQuit = GS_VideoQuit;
	this->AllocHWSurface = GS_AllocHWSurface;
	this->CheckHWBlit = NULL;
	this->FillHWRect = NULL;
	this->SetHWColorKey = NULL;
	this->SetHWAlpha = NULL;
	this->LockHWSurface = GS_LockHWSurface;
	this->UnlockHWSurface = GS_UnlockHWSurface;
	this->FlipHWSurface = NULL;
	this->FreeHWSurface = GS_FreeHWSurface;
	this->SetIcon = NULL;
	this->SetCaption = NULL;
	this->GetWMInfo = NULL;
	this->FreeWMCursor = GS_FreeWMCursor;
	this->CreateWMCursor = GS_CreateWMCursor;
	this->ShowWMCursor = GS_ShowWMCursor;
	this->MoveWMCursor = GS_MoveWMCursor;
	this->InitOSKeymap = GS_InitOSKeymap;
	this->PumpEvents = GS_PumpEvents;

	this->free = GS_DeleteDevice;

	return this;
}

VideoBootStrap PS2GS_bootstrap = {
	"ps2gs", "PlayStation 2 Graphics Synthesizer",
	GS_Available, GS_CreateDevice
};

/* These are the pixel formats for the 32, 24, and 16 bit video modes */
static struct {
	int bpp;
	Uint32 r;
	Uint32 g;
	Uint32 b;
} GS_pixelmasks[] = {
	{ 32, 0x000000FF,	/* RGB little-endian */
	      0x0000FF00,
	      0x00FF0000 },
	{ 24, 0x000000FF,	/* RGB little-endian */
	      0x0000FF00,
	      0x00FF0000 },
	{ 16, 0x0000001f,	/* RGB little-endian */
	      0x000003e0,
	      0x00007c00 },
};
/* This is a mapping from SDL bytes-per-pixel to GS pixel format */
static int GS_formatmap[] = {
	-1,		/* 0 bpp, not a legal value */
	-1,		/* 8 bpp, not supported (yet?) */
	PS2_GS_PSMCT16,	/* 16 bpp */
	PS2_GS_PSMCT24,	/* 24 bpp */
	PS2_GS_PSMCT32	/* 32 bpp */
};

static unsigned long long head_tags[] __attribute__((aligned(16))) = {
	4 | (1LL << 60),	/* GIFtag */
	0x0e,			/* A+D */
	0,			/* 2 */
	PS2_GS_BITBLTBUF,
	0,			/* 4 */
	PS2_GS_TRXPOS,
	0,			/* 6 */
	PS2_GS_TRXREG,
	0,			/* 8 */
	PS2_GS_TRXDIR
};

#define MAXIMG		(32767 * 16)
#define MAXTAGS		8

static inline int loadimage_nonblock(int fd, struct ps2_image *image, int size,
                                     unsigned long long *hm,
                                     unsigned long long *im)
{
	struct ps2_plist plist;
	struct ps2_packet packet[1 + MAXTAGS * 2];
	int isize;
	int pnum, it, eop;
	char *data;

	/* initialize the variables */
	data = (char *)image->ptr;
	pnum = it = eop = 0;
	plist.packet = packet;

	/* make BITBLT packet */
	packet[pnum].ptr = hm;
	packet[pnum].len = sizeof(head_tags);
	pnum++;
	hm[2] = ((unsigned long long)image->fbp << 32) |
	        ((unsigned long long)image->fbw << 48) |
	        ((unsigned long long)image->psm << 56);
	hm[4] = ((unsigned long long)image->x << 32) |
	        ((unsigned long long)image->y << 48);
	hm[6] = (unsigned long long)image->w |
	        ((unsigned long long)image->h << 32);

	/* make image mode tags */
	while (!eop) {
		isize = size > MAXIMG ? MAXIMG : size;
		size -= isize;
		eop = (size == 0);

		packet[pnum].ptr = &im[it];
		packet[pnum].len = sizeof(unsigned long long) * 2;
		pnum++;
		im[it++] = (isize >> 4) | (eop ? (1 << 15) : 0) | (2LL << 58);
		im[it++] = 0;

		packet[pnum].ptr = (void *)data;
		packet[pnum].len = isize;
		pnum++;
		data += isize;
	}
	plist.num = pnum;

	return ioctl(fd, PS2IOC_SENDL, &plist);
}

static unsigned long long tex_tags[] __attribute__((aligned(16))) = {
	3 | (1LL << 60),	/* GIFtag */
	0x0e,			/* A+D */
	0,			/* 2 */
	PS2_GS_TEX0_1,
	(1 << 5) + (1 << 6),
	PS2_GS_TEX1_1,
	0,
	PS2_GS_TEXFLUSH
};
static unsigned long long scale_tags[] __attribute__((aligned(16))) = {
	5 | (1LL << 60),	/* GIFtag */
	0x0e,			/* A+D */
	6 + (1 << 4) + (1 << 8),
	PS2_GS_PRIM,
	((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16),
	PS2_GS_UV,
	((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16),
	PS2_GS_XYZ2,
	0,			/* 8 */
	PS2_GS_UV,
	0,			/* 10 */
	PS2_GS_XYZ2
};


int scaleimage_nonblock(int fd, unsigned long long *tm, unsigned long long *sm)
{
	struct ps2_plist plist;
	struct ps2_packet packet[2];

	/* initialize the variables */
	plist.num = 2;
	plist.packet = packet;

	packet[0].ptr = tm;
	packet[0].len = sizeof(tex_tags);
	packet[1].ptr = sm;
	packet[1].len = sizeof(scale_tags);

	return ioctl(fd, PS2IOC_SENDL, &plist);
}

static int power_of_2(int value)
{
	int shift;

	for ( shift = 0; (1<<shift) < value; ++shift ) {
		/* Keep looking */ ;
	}
	return(shift);
}

static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat)
{
	struct ps2_screeninfo vinfo;

	/* Initialize the library */
	console_fd = open(PS2_DEV_GS, O_RDWR, 0);
	if ( console_fd < 0 ) {
		SDL_SetError("Unable to open %s", PS2_DEV_GS);
		return(-1);
	}
	memory_fd = open(PS2_DEV_MEM, O_RDWR, 0);
	if ( memory_fd < 0 ) {
		close(console_fd);
		console_fd = -1;
		SDL_SetError("Unable to open %s", PS2_DEV_MEM);
		return(-1);
	}

	if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) {
		close(memory_fd);
		close(console_fd);
		console_fd = -1;
		SDL_SetError("Couldn't get console pixel format");
		return(-1);
	}

	/* Determine the current screen size */
	this->info.current_w = vinfo.w;
	this->info.current_h = vinfo.h;

	/* Determine the current screen depth */
	switch (vinfo.psm) {
	    /* Supported pixel formats */
	    case PS2_GS_PSMCT32:
	    case PS2_GS_PSMCT24:
	    case PS2_GS_PSMCT16:
		break;
	    default:
		GS_VideoQuit(this);
		SDL_SetError("Unknown console pixel format: %d", vinfo.psm);
		return(-1);
	}
	vformat->BitsPerPixel = GS_pixelmasks[vinfo.psm].bpp;
	vformat->Rmask = GS_pixelmasks[vinfo.psm].r;
	vformat->Gmask = GS_pixelmasks[vinfo.psm].g;
	vformat->Bmask = GS_pixelmasks[vinfo.psm].b;
	saved_vinfo = vinfo;

	/* Enable mouse and keyboard support */
	if ( GS_OpenKeyboard(this) < 0 ) {
		GS_VideoQuit(this);
		SDL_SetError("Unable to open keyboard");
		return(-1);
	}
	if ( GS_OpenMouse(this) < 0 ) {
		const char *sdl_nomouse;

		sdl_nomouse = SDL_getenv("SDL_NOMOUSE");
		if ( ! sdl_nomouse ) {
			GS_VideoQuit(this);
			SDL_SetError("Unable to open mouse");
			return(-1);
		}
	}

	/* We're done! */
	return(0);
}

static SDL_Rect **GS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
{
	static SDL_Rect GS_vesa_mode_list[] = {
		{ 0, 0, 1280, 1024 },
		{ 0, 0, 1024, 768 },
		{ 0, 0, 800, 600 },
		{ 0, 0, 640, 480 }
	};
	static SDL_Rect *GS_vesa_modes[] = {
		&GS_vesa_mode_list[0],
		&GS_vesa_mode_list[1],
		&GS_vesa_mode_list[2],
		&GS_vesa_mode_list[3],
		NULL
	};
	static SDL_Rect GS_tvout_stretch;
	static SDL_Rect GS_tvout_mode;
	static SDL_Rect *GS_tvout_modes[3];
	SDL_Rect **modes = NULL;

	switch (format->BitsPerPixel) {
	    case 16:
	    case 24:
	    case 32:
		if ( saved_vinfo.mode == PS2_GS_VESA ) {
			modes = GS_vesa_modes;
		} else {
			int i, j = 0;

// FIXME - what's wrong with the stretch code at 16 bpp?
if ( format->BitsPerPixel != 32 ) break;
			/* Add a mode that we could possibly stretch to */
			for ( i=0; GS_vesa_modes[i]; ++i ) {
				if ( (GS_vesa_modes[i]->w == saved_vinfo.w) &&
				     (GS_vesa_modes[i]->h != saved_vinfo.h) ) {
					GS_tvout_stretch.w=GS_vesa_modes[i]->w;
					GS_tvout_stretch.h=GS_vesa_modes[i]->h;
					GS_tvout_modes[j++] = &GS_tvout_stretch;
					break;
				}
			}
			/* Add the current TV video mode */
			GS_tvout_mode.w = saved_vinfo.w;
			GS_tvout_mode.h = saved_vinfo.h;
			GS_tvout_modes[j++] = &GS_tvout_mode;
			GS_tvout_modes[j++] = NULL;

			/* Return the created list of modes */
			modes = GS_tvout_modes;
		}
		break;
	    default:
		break;
	}
	return(modes);
}

/* Various screen update functions available */
static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects);

static SDL_Surface *GS_SetVideoMode(_THIS, SDL_Surface *current,
				int width, int height, int bpp, Uint32 flags)
{
	struct ps2_screeninfo vinfo;

	/* Set the terminal into graphics mode */
	if ( GS_EnterGraphicsMode(this) < 0 ) {
		return(NULL);
	}

	/* Set the video mode and get the final screen format */
	if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) {
		SDL_SetError("Couldn't get console screen info");
		return(NULL);
	}
	if ( (vinfo.w != width) || (vinfo.h != height) ||
	     (GS_pixelmasks[vinfo.psm].bpp != bpp) ) {
		/* If we're not in VESA mode, we have to scale resolution */
		if ( saved_vinfo.mode == PS2_GS_VESA ) {
			switch (width) {
			    case 640:
				vinfo.res = PS2_GS_640x480;
				break;
			    case 800:
				vinfo.res = PS2_GS_800x600;
				break;
			    case 1024:
				vinfo.res = PS2_GS_1024x768;
				break;
			    case 1280:
				vinfo.res = PS2_GS_1280x1024;
				break;
			    default:
				SDL_SetError("Unsupported resolution: %dx%d\n",
					     width, height);
				return(NULL);
			}
			vinfo.res |= (PS2_GS_75Hz << 8);
			vinfo.w = width;
			vinfo.h = height;
		}
		vinfo.fbp = 0;
		vinfo.psm = GS_formatmap[bpp/8];
		if ( vinfo.psm < 0 ) {
			SDL_SetError("Unsupported depth: %d bpp\n", bpp);
			return(NULL);
		}
		if ( ioctl(console_fd, PS2IOC_SSCREENINFO, &vinfo) < 0 ) {
			SDL_SetError("Couldn't set console screen info");
			return(NULL);
		}

		/* Unmap the previous DMA buffer */
		if ( mapped_mem ) {
			munmap(mapped_mem, mapped_len);
			mapped_mem = NULL;
		}
	}
	if ( ! SDL_ReallocFormat(current, GS_pixelmasks[vinfo.psm].bpp,
	                                  GS_pixelmasks[vinfo.psm].r,
	                                  GS_pixelmasks[vinfo.psm].g,
	                                  GS_pixelmasks[vinfo.psm].b, 0) ) {
		return(NULL);
	}

	/* Set up the new mode framebuffer */
	current->flags = SDL_FULLSCREEN;
	current->w = width;
	current->h = height;
	current->pitch = SDL_CalculatePitch(current);

	/* Memory map the DMA area for block memory transfer */
	if ( ! mapped_mem ) {
		pixels_len = height * current->pitch;
		mapped_len = pixels_len +
		             /* Screen update DMA command area */
		             sizeof(head_tags) + ((2 * MAXTAGS) * 16);
		if ( saved_vinfo.mode != PS2_GS_VESA ) {
			mapped_len += sizeof(tex_tags) + sizeof(scale_tags);
		}
		mapped_mem = mmap(0, mapped_len, PROT_READ|PROT_WRITE,
		                  MAP_SHARED, memory_fd, 0);
		if ( mapped_mem == MAP_FAILED ) {
			SDL_SetError("Unable to map %d bytes for DMA",
			             mapped_len);
			mapped_mem = NULL;
			return(NULL);
		}

		/* Set up the entire screen for DMA transfer */
		screen_image.ptr = mapped_mem;
		screen_image.fbp = 0;
		screen_image.fbw = (vinfo.w + 63) / 64;
		screen_image.psm = vinfo.psm;
		screen_image.x = 0;
		if ( vinfo.h == height ) {
			screen_image.y = 0;
		} else {
			/* Put image offscreen and scale to screen height */
			screen_image.y = vinfo.h;
		}
		screen_image.w = current->w;
		screen_image.h = current->h;

		/* get screen image data size (qword aligned) */
		screen_image_size = (screen_image.w * screen_image.h);
		switch (screen_image.psm) {
		    case PS2_GS_PSMCT32:
			screen_image_size *= 4;
			break;
		    case PS2_GS_PSMCT24:
			screen_image_size *= 3;
			break;
		    case PS2_GS_PSMCT16:
			screen_image_size *= 2;
			break;
		}
		screen_image_size = (screen_image_size + 15) & ~15;

		/* Set up the memory for screen update DMA commands */
		head_tags_mem = (unsigned long long *)
		                (mapped_mem + pixels_len);
		image_tags_mem = (unsigned long long *)
		                 ((caddr_t)head_tags_mem + sizeof(head_tags));
		SDL_memcpy(head_tags_mem, head_tags, sizeof(head_tags));
		if ( saved_vinfo.mode != PS2_GS_VESA ) {
			tex_tags_mem = (unsigned long long *)
		                 ((caddr_t)image_tags_mem + ((2*MAXTAGS)*16));
			scale_tags_mem = (unsigned long long *)
		                 ((caddr_t)tex_tags_mem + sizeof(tex_tags));
			SDL_memcpy(tex_tags_mem, tex_tags, sizeof(tex_tags));
			tex_tags_mem[2] = 
				(vinfo.h * vinfo.w) / 64 +
	          		((unsigned long long)screen_image.fbw << 14) +
	          		((unsigned long long)screen_image.psm << 20) +
	          		((unsigned long long)power_of_2(screen_image.w) << 26) +
	          		((unsigned long long)power_of_2(screen_image.h) << 30) +
	          		((unsigned long long)1 << 34) +
	          		((unsigned long long)1 << 35);
			SDL_memcpy(scale_tags_mem, scale_tags, sizeof(scale_tags));
			scale_tags_mem[8] =
				((unsigned long long)screen_image.w * 16) +
			         (((unsigned long long)screen_image.h * 16) << 16);
			scale_tags_mem[10] =
				((unsigned long long)vinfo.w * 16) +
			         (((unsigned long long)vinfo.h * 16) << 16);
		}
	}
	current->pixels = NULL;
	if ( SDL_getenv("SDL_FULLSCREEN_UPDATE") ) {
		/* Correct semantics */
		current->flags |= SDL_ASYNCBLIT;
	} else {
		/* We lie here - the screen memory isn't really the visible
		   display memory and still requires an update, but this
		   has the desired effect for most applications.
		 */
		current->flags |= SDL_HWSURFACE;
	}

	/* Set the update rectangle function */
	this->UpdateRects = GS_DMAFullUpdate;

	/* We're done */
	return(current);
}

/* We don't support hardware surfaces yet */
static int GS_AllocHWSurface(_THIS, SDL_Surface *surface)
{
	return(-1);
}
static void GS_FreeHWSurface(_THIS, SDL_Surface *surface)
{
	return;
}
static int GS_LockHWSurface(_THIS, SDL_Surface *surface)
{
	if ( surface == this->screen ) {
		/* Since mouse motion affects 'pixels', lock it */
		SDL_LockCursor();

		/* Make sure any pending DMA has completed */
		if ( dma_pending ) {
			ioctl(console_fd, PS2IOC_SENDQCT, 1);
			dma_pending = 0;
		}

		/* If the cursor is drawn on the DMA area, remove it */
		if ( cursor_drawn ) {
			surface->pixels = mapped_mem + surface->offset;
			SDL_EraseCursorNoLock(this->screen);
			cursor_drawn = 0;
		}

		/* Set the surface pixels to the base of the DMA area */
		surface->pixels = mapped_mem;

		/* We're finished! */
		SDL_UnlockCursor();
	}
	return(0);
}
static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface)
{
	if ( surface == this->screen ) {
		/* Since mouse motion affects 'pixels', lock it */
		SDL_LockCursor();
		surface->pixels = NULL;
		SDL_UnlockCursor();
	}
}

static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects)
{
	/* Lock so we aren't interrupted by a mouse update */
	SDL_LockCursor();

	/* Make sure any pending DMA has completed */
	if ( dma_pending ) {
		ioctl(console_fd, PS2IOC_SENDQCT, 1);
		dma_pending = 0;
	}

	/* If the mouse is visible, draw it on the DMA area */
	if ( (SDL_cursorstate & CURSOR_VISIBLE) && !cursor_drawn ) {
		this->screen->pixels = mapped_mem + this->screen->offset;
		SDL_DrawCursorNoLock(this->screen);
		this->screen->pixels = NULL;
		cursor_drawn = 1;
	}

	/* Put the image onto the screen */
	loadimage_nonblock(console_fd,
	                   &screen_image, screen_image_size,
	                   head_tags_mem, image_tags_mem);
	if ( screen_image.y > 0 ) {
		/* Need to scale offscreen image to TV output */
		ioctl(console_fd, PS2IOC_SENDQCT, 1);
		dma_pending = 0;
		scaleimage_nonblock(console_fd, tex_tags_mem, scale_tags_mem);
	} else {
		dma_pending = 1;
	}

	/* We're finished! */
	SDL_UnlockCursor();
}

static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
{
	return(0);
}

static void GS_VideoQuit(_THIS)
{
	/* Close console and input file descriptors */
	if ( console_fd > 0 ) {
		/* Unmap the video framebuffer */
		if ( mapped_mem ) {
			/* Unmap the video framebuffer */
			munmap(mapped_mem, mapped_len);
			mapped_mem = NULL;
		}
		close(memory_fd);

		/* Restore the original video mode */
		if ( GS_InGraphicsMode(this) ) {
			ioctl(console_fd, PS2IOC_SSCREENINFO, &saved_vinfo);
		}

		/* We're all done with the graphics device */
		close(console_fd);
		console_fd = -1;
	}
	GS_CloseMouse(this);
	GS_CloseKeyboard(this);
}
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	Sam Lantinga
	20	slouken@libsdl.org
	21	*/
	22	#include "SDL_config.h"
	23
	24	/* Framebuffer console based SDL video driver implementation.
	25	*/
	26
	27	#include <fcntl.h>
	28	#include <unistd.h>
	29	#include <sys/ioctl.h>
	30	#include <sys/mman.h>
	31
	32	#include "SDL_video.h"
	33	#include "SDL_mouse.h"
	34	#include "../SDL_sysvideo.h"
	35	#include "../SDL_pixels_c.h"
	36	#include "../../events/SDL_events_c.h"
	37	#include "../SDL_cursor_c.h"
	38	#include "SDL_gsvideo.h"
	39	#include "SDL_gsmouse_c.h"
	40	#include "SDL_gsevents_c.h"
	41	#include "SDL_gsyuv_c.h"
	42
	43
	44	/* Initialization/Query functions */
	45	static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat);
	46	static SDL_Rect *GS_ListModes(_THIS, SDL_PixelFormat format, Uint32 flags);
	47	static SDL_Surface GS_SetVideoMode(_THIS, SDL_Surface current, int width, int height, int bpp, Uint32 flags);
	48	static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
	49	static void GS_VideoQuit(_THIS);
	50
	51	/* Hardware surface functions */
	52	static int GS_AllocHWSurface(_THIS, SDL_Surface *surface);
	53	static int GS_LockHWSurface(_THIS, SDL_Surface *surface);
	54	static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface);
	55	static void GS_FreeHWSurface(_THIS, SDL_Surface *surface);
	56
	57	/* GS driver bootstrap functions */
	58
	59	static int GS_Available(void)
	60	{
	61	int console, memory;
	62
	63	console = open(PS2_DEV_GS, O_RDWR, 0);
	64	if ( console >= 0 ) {
65	close(console);
66	}
67	memory = open(PS2_DEV_MEM, O_RDWR, 0);
68	if ( memory >= 0 ) {
69	close(memory);
70	}
71	return((console >= 0) && (memory >= 0));
72	}
73
74	static void GS_DeleteDevice(SDL_VideoDevice *device)
75	{
76	SDL_free(device->hidden);
77	SDL_free(device);
78	}
79
80	static SDL_VideoDevice *GS_CreateDevice(int devindex)
81	{
82	SDL_VideoDevice *this;
83
84	/* Initialize all variables that we clean on shutdown */
85	this = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
86	if ( this ) {
87	SDL_memset(this, 0, (sizeof *this));
88	this->hidden = (struct SDL_PrivateVideoData *)
89	SDL_malloc((sizeof *this->hidden));
90	}
91	if ( (this == NULL) \|\| (this->hidden == NULL) ) {
92	SDL_OutOfMemory();
93	if ( this ) {
94	SDL_free(this);
95	}
96	return(0);
97	}
98	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
99	mouse_fd = -1;
100	keyboard_fd = -1;
101
102	/* Set the function pointers */
103	this->VideoInit = GS_VideoInit;
104	this->ListModes = GS_ListModes;
105	this->SetVideoMode = GS_SetVideoMode;
106	this->CreateYUVOverlay = GS_CreateYUVOverlay;
107	this->SetColors = GS_SetColors;
108	this->UpdateRects = NULL;
109	this->VideoQuit = GS_VideoQuit;
110	this->AllocHWSurface = GS_AllocHWSurface;
111	this->CheckHWBlit = NULL;
112	this->FillHWRect = NULL;
113	this->SetHWColorKey = NULL;
114	this->SetHWAlpha = NULL;
115	this->LockHWSurface = GS_LockHWSurface;
116	this->UnlockHWSurface = GS_UnlockHWSurface;
117	this->FlipHWSurface = NULL;
118	this->FreeHWSurface = GS_FreeHWSurface;
119	this->SetIcon = NULL;
120	this->SetCaption = NULL;
121	this->GetWMInfo = NULL;
122	this->FreeWMCursor = GS_FreeWMCursor;
123	this->CreateWMCursor = GS_CreateWMCursor;
124	this->ShowWMCursor = GS_ShowWMCursor;
125	this->MoveWMCursor = GS_MoveWMCursor;
126	this->InitOSKeymap = GS_InitOSKeymap;
127	this->PumpEvents = GS_PumpEvents;
128
129	this->free = GS_DeleteDevice;
130
131	return this;
132	}
133
134	VideoBootStrap PS2GS_bootstrap = {
135	"ps2gs", "PlayStation 2 Graphics Synthesizer",
136	GS_Available, GS_CreateDevice
137	};
138
139	/* These are the pixel formats for the 32, 24, and 16 bit video modes */
140	static struct {
141	int bpp;
142	Uint32 r;
143	Uint32 g;
144	Uint32 b;
145	} GS_pixelmasks[] = {
146	{ 32, 0x000000FF, /* RGB little-endian */
147	0x0000FF00,
148	0x00FF0000 },
149	{ 24, 0x000000FF, /* RGB little-endian */
150	0x0000FF00,
151	0x00FF0000 },
152	{ 16, 0x0000001f, /* RGB little-endian */
153	0x000003e0,
154	0x00007c00 },
155	};
156	/* This is a mapping from SDL bytes-per-pixel to GS pixel format */
157	static int GS_formatmap[] = {
158	-1, /* 0 bpp, not a legal value */
159	-1, /* 8 bpp, not supported (yet?) */
160	PS2_GS_PSMCT16, /* 16 bpp */
161	PS2_GS_PSMCT24, /* 24 bpp */
162	PS2_GS_PSMCT32 /* 32 bpp */
163	};
164
165	static unsigned long long head_tags[] __attribute__((aligned(16))) = {
166	4 \| (1LL << 60), /* GIFtag */
167	0x0e, /* A+D */
168	0, /* 2 */
169	PS2_GS_BITBLTBUF,
170	0, /* 4 */
171	PS2_GS_TRXPOS,
172	0, /* 6 */
173	PS2_GS_TRXREG,
174	0, /* 8 */
175	PS2_GS_TRXDIR
176	};
177
178	#define MAXIMG (32767 * 16)
179	#define MAXTAGS 8
180
181	static inline int loadimage_nonblock(int fd, struct ps2_image *image, int size,
182	unsigned long long *hm,
183	unsigned long long *im)
184	{
185	struct ps2_plist plist;
186	struct ps2_packet packet[1 + MAXTAGS * 2];
187	int isize;
188	int pnum, it, eop;
189	char *data;
190
191	/* initialize the variables */
192	data = (char *)image->ptr;
193	pnum = it = eop = 0;
194	plist.packet = packet;
195
196	/* make BITBLT packet */
197	packet[pnum].ptr = hm;
198	packet[pnum].len = sizeof(head_tags);
199	pnum++;
200	hm[2] = ((unsigned long long)image->fbp << 32) \|
201	((unsigned long long)image->fbw << 48) \|
202	((unsigned long long)image->psm << 56);
203	hm[4] = ((unsigned long long)image->x << 32) \|
204	((unsigned long long)image->y << 48);
205	hm[6] = (unsigned long long)image->w \|
206	((unsigned long long)image->h << 32);
207
208	/* make image mode tags */
209	while (!eop) {
210	isize = size > MAXIMG ? MAXIMG : size;
211	size -= isize;
212	eop = (size == 0);
213
214	packet[pnum].ptr = &im[it];
215	packet[pnum].len = sizeof(unsigned long long) * 2;
216	pnum++;
217	im[it++] = (isize >> 4) \| (eop ? (1 << 15) : 0) \| (2LL << 58);
218	im[it++] = 0;
219
220	packet[pnum].ptr = (void *)data;
221	packet[pnum].len = isize;
222	pnum++;
223	data += isize;
224	}
225	plist.num = pnum;
226
227	return ioctl(fd, PS2IOC_SENDL, &plist);
228	}
229
230	static unsigned long long tex_tags[] __attribute__((aligned(16))) = {
231	3 \| (1LL << 60), /* GIFtag */
232	0x0e, /* A+D */
233	0, /* 2 */
234	PS2_GS_TEX0_1,
235	(1 << 5) + (1 << 6),
236	PS2_GS_TEX1_1,
237	0,
238	PS2_GS_TEXFLUSH
239	};
240	static unsigned long long scale_tags[] __attribute__((aligned(16))) = {
241	5 \| (1LL << 60), /* GIFtag */
242	0x0e, /* A+D */
243	6 + (1 << 4) + (1 << 8),
244	PS2_GS_PRIM,
245	((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16),
246	PS2_GS_UV,
247	((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16),
248	PS2_GS_XYZ2,
249	0, /* 8 */
250	PS2_GS_UV,
251	0, /* 10 */
252	PS2_GS_XYZ2
253	};
254
255
256	int scaleimage_nonblock(int fd, unsigned long long tm, unsigned long long sm)
257	{
258	struct ps2_plist plist;
259	struct ps2_packet packet[2];
260
261	/* initialize the variables */
262	plist.num = 2;
263	plist.packet = packet;
264
265	packet[0].ptr = tm;
266	packet[0].len = sizeof(tex_tags);
267	packet[1].ptr = sm;
268	packet[1].len = sizeof(scale_tags);
269
270	return ioctl(fd, PS2IOC_SENDL, &plist);
271	}
272
273	static int power_of_2(int value)
274	{
275	int shift;
276
277	for ( shift = 0; (1<<shift) < value; ++shift ) {
278	/* Keep looking */ ;
279	}
280	return(shift);
281	}
282
283	static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat)
284	{
285	struct ps2_screeninfo vinfo;
286
287	/* Initialize the library */
288	console_fd = open(PS2_DEV_GS, O_RDWR, 0);
289	if ( console_fd < 0 ) {
290	SDL_SetError("Unable to open %s", PS2_DEV_GS);
291	return(-1);
292	}
293	memory_fd = open(PS2_DEV_MEM, O_RDWR, 0);
294	if ( memory_fd < 0 ) {
295	close(console_fd);
296	console_fd = -1;
297	SDL_SetError("Unable to open %s", PS2_DEV_MEM);
298	return(-1);
299	}
300
301	if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) {
302	close(memory_fd);
303	close(console_fd);
304	console_fd = -1;
305	SDL_SetError("Couldn't get console pixel format");
306	return(-1);
307	}
308
309	/* Determine the current screen size */
310	this->info.current_w = vinfo.w;
311	this->info.current_h = vinfo.h;
312
313	/* Determine the current screen depth */
314	switch (vinfo.psm) {
315	/* Supported pixel formats */
316	case PS2_GS_PSMCT32:
317	case PS2_GS_PSMCT24:
318	case PS2_GS_PSMCT16:
319	break;
320	default:
321	GS_VideoQuit(this);
322	SDL_SetError("Unknown console pixel format: %d", vinfo.psm);
323	return(-1);
324	}
325	vformat->BitsPerPixel = GS_pixelmasks[vinfo.psm].bpp;
326	vformat->Rmask = GS_pixelmasks[vinfo.psm].r;
327	vformat->Gmask = GS_pixelmasks[vinfo.psm].g;
328	vformat->Bmask = GS_pixelmasks[vinfo.psm].b;
329	saved_vinfo = vinfo;
330
331	/* Enable mouse and keyboard support */
332	if ( GS_OpenKeyboard(this) < 0 ) {
333	GS_VideoQuit(this);
334	SDL_SetError("Unable to open keyboard");
335	return(-1);
336	}
337	if ( GS_OpenMouse(this) < 0 ) {
338	const char *sdl_nomouse;
339
340	sdl_nomouse = SDL_getenv("SDL_NOMOUSE");
341	if ( ! sdl_nomouse ) {
342	GS_VideoQuit(this);
343	SDL_SetError("Unable to open mouse");
344	return(-1);
345	}
346	}
347
348	/* We're done! */
349	return(0);
350	}
351
352	static SDL_Rect *GS_ListModes(_THIS, SDL_PixelFormat format, Uint32 flags)
353	{
354	static SDL_Rect GS_vesa_mode_list[] = {
355	{ 0, 0, 1280, 1024 },
356	{ 0, 0, 1024, 768 },
357	{ 0, 0, 800, 600 },
358	{ 0, 0, 640, 480 }
359	};
360	static SDL_Rect *GS_vesa_modes[] = {
361	&GS_vesa_mode_list[0],
362	&GS_vesa_mode_list[1],
363	&GS_vesa_mode_list[2],
364	&GS_vesa_mode_list[3],
365	NULL
366	};
367	static SDL_Rect GS_tvout_stretch;
368	static SDL_Rect GS_tvout_mode;
369	static SDL_Rect *GS_tvout_modes[3];
370	SDL_Rect **modes = NULL;
371
372	switch (format->BitsPerPixel) {
373	case 16:
374	case 24:
375	case 32:
376	if ( saved_vinfo.mode == PS2_GS_VESA ) {
377	modes = GS_vesa_modes;
378	} else {
379	int i, j = 0;
380
381	// FIXME - what's wrong with the stretch code at 16 bpp?
382	if ( format->BitsPerPixel != 32 ) break;
383	/* Add a mode that we could possibly stretch to */
384	for ( i=0; GS_vesa_modes[i]; ++i ) {
385	if ( (GS_vesa_modes[i]->w == saved_vinfo.w) &&
386	(GS_vesa_modes[i]->h != saved_vinfo.h) ) {
387	GS_tvout_stretch.w=GS_vesa_modes[i]->w;
388	GS_tvout_stretch.h=GS_vesa_modes[i]->h;
389	GS_tvout_modes[j++] = &GS_tvout_stretch;
390	break;
391	}
392	}
393	/* Add the current TV video mode */
394	GS_tvout_mode.w = saved_vinfo.w;
395	GS_tvout_mode.h = saved_vinfo.h;
396	GS_tvout_modes[j++] = &GS_tvout_mode;
397	GS_tvout_modes[j++] = NULL;
398
399	/* Return the created list of modes */
400	modes = GS_tvout_modes;
401	}
402	break;
403	default:
404	break;
405	}
406	return(modes);
407	}
408
409	/* Various screen update functions available */
410	static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects);
411
412	static SDL_Surface GS_SetVideoMode(_THIS, SDL_Surface current,
413	int width, int height, int bpp, Uint32 flags)
414	{
415	struct ps2_screeninfo vinfo;
416
417	/* Set the terminal into graphics mode */
418	if ( GS_EnterGraphicsMode(this) < 0 ) {
419	return(NULL);
420	}
421
422	/* Set the video mode and get the final screen format */
423	if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) {
424	SDL_SetError("Couldn't get console screen info");
425	return(NULL);
426	}
427	if ( (vinfo.w != width) \|\| (vinfo.h != height) \|\|
428	(GS_pixelmasks[vinfo.psm].bpp != bpp) ) {
429	/* If we're not in VESA mode, we have to scale resolution */
430	if ( saved_vinfo.mode == PS2_GS_VESA ) {
431	switch (width) {
432	case 640:
433	vinfo.res = PS2_GS_640x480;
434	break;
435	case 800:
436	vinfo.res = PS2_GS_800x600;
437	break;
438	case 1024:
439	vinfo.res = PS2_GS_1024x768;
440	break;
441	case 1280:
442	vinfo.res = PS2_GS_1280x1024;
443	break;
444	default:
445	SDL_SetError("Unsupported resolution: %dx%d\n",
446	width, height);
447	return(NULL);
448	}
449	vinfo.res \|= (PS2_GS_75Hz << 8);
450	vinfo.w = width;
451	vinfo.h = height;
452	}
453	vinfo.fbp = 0;
454	vinfo.psm = GS_formatmap[bpp/8];
455	if ( vinfo.psm < 0 ) {
456	SDL_SetError("Unsupported depth: %d bpp\n", bpp);
457	return(NULL);
458	}
459	if ( ioctl(console_fd, PS2IOC_SSCREENINFO, &vinfo) < 0 ) {
460	SDL_SetError("Couldn't set console screen info");
461	return(NULL);
462	}
463
464	/* Unmap the previous DMA buffer */
465	if ( mapped_mem ) {
466	munmap(mapped_mem, mapped_len);
467	mapped_mem = NULL;
468	}
469	}
470	if ( ! SDL_ReallocFormat(current, GS_pixelmasks[vinfo.psm].bpp,
471	GS_pixelmasks[vinfo.psm].r,
472	GS_pixelmasks[vinfo.psm].g,
473	GS_pixelmasks[vinfo.psm].b, 0) ) {
474	return(NULL);
475	}
476
477	/* Set up the new mode framebuffer */
478	current->flags = SDL_FULLSCREEN;
479	current->w = width;
480	current->h = height;
481	current->pitch = SDL_CalculatePitch(current);
482
483	/* Memory map the DMA area for block memory transfer */
484	if ( ! mapped_mem ) {
485	pixels_len = height * current->pitch;
486	mapped_len = pixels_len +
487	/* Screen update DMA command area */
488	sizeof(head_tags) + ((2 * MAXTAGS) * 16);
489	if ( saved_vinfo.mode != PS2_GS_VESA ) {
490	mapped_len += sizeof(tex_tags) + sizeof(scale_tags);
491	}
492	mapped_mem = mmap(0, mapped_len, PROT_READ\|PROT_WRITE,
493	MAP_SHARED, memory_fd, 0);
494	if ( mapped_mem == MAP_FAILED ) {
495	SDL_SetError("Unable to map %d bytes for DMA",
496	mapped_len);
497	mapped_mem = NULL;
498	return(NULL);
499	}
500
501	/* Set up the entire screen for DMA transfer */
502	screen_image.ptr = mapped_mem;
503	screen_image.fbp = 0;
504	screen_image.fbw = (vinfo.w + 63) / 64;
505	screen_image.psm = vinfo.psm;
506	screen_image.x = 0;
507	if ( vinfo.h == height ) {
508	screen_image.y = 0;
509	} else {
510	/* Put image offscreen and scale to screen height */
511	screen_image.y = vinfo.h;
512	}
513	screen_image.w = current->w;
514	screen_image.h = current->h;
515
516	/* get screen image data size (qword aligned) */
517	screen_image_size = (screen_image.w * screen_image.h);
518	switch (screen_image.psm) {
519	case PS2_GS_PSMCT32:
520	screen_image_size *= 4;
521	break;
522	case PS2_GS_PSMCT24:
523	screen_image_size *= 3;
524	break;
525	case PS2_GS_PSMCT16:
526	screen_image_size *= 2;
527	break;
528	}
529	screen_image_size = (screen_image_size + 15) & ~15;
530
531	/* Set up the memory for screen update DMA commands */
532	head_tags_mem = (unsigned long long *)
533	(mapped_mem + pixels_len);
534	image_tags_mem = (unsigned long long *)
535	((caddr_t)head_tags_mem + sizeof(head_tags));
536	SDL_memcpy(head_tags_mem, head_tags, sizeof(head_tags));
537	if ( saved_vinfo.mode != PS2_GS_VESA ) {
538	tex_tags_mem = (unsigned long long *)
539	((caddr_t)image_tags_mem + ((2MAXTAGS)16));
540	scale_tags_mem = (unsigned long long *)
541	((caddr_t)tex_tags_mem + sizeof(tex_tags));
542	SDL_memcpy(tex_tags_mem, tex_tags, sizeof(tex_tags));
543	tex_tags_mem[2] =
544	(vinfo.h * vinfo.w) / 64 +
545	((unsigned long long)screen_image.fbw << 14) +
546	((unsigned long long)screen_image.psm << 20) +
547	((unsigned long long)power_of_2(screen_image.w) << 26) +
548	((unsigned long long)power_of_2(screen_image.h) << 30) +
549	((unsigned long long)1 << 34) +
550	((unsigned long long)1 << 35);
551	SDL_memcpy(scale_tags_mem, scale_tags, sizeof(scale_tags));
552	scale_tags_mem[8] =
553	((unsigned long long)screen_image.w * 16) +
554	(((unsigned long long)screen_image.h * 16) << 16);
555	scale_tags_mem[10] =
556	((unsigned long long)vinfo.w * 16) +
557	(((unsigned long long)vinfo.h * 16) << 16);
558	}
559	}
560	current->pixels = NULL;
561	if ( SDL_getenv("SDL_FULLSCREEN_UPDATE") ) {
562	/* Correct semantics */
563	current->flags \|= SDL_ASYNCBLIT;
564	} else {
565	/* We lie here - the screen memory isn't really the visible
566	display memory and still requires an update, but this
567	has the desired effect for most applications.
568	*/
569	current->flags \|= SDL_HWSURFACE;
570	}
571
572	/* Set the update rectangle function */
573	this->UpdateRects = GS_DMAFullUpdate;
574
575	/* We're done */
576	return(current);
577	}
578
579	/* We don't support hardware surfaces yet */
580	static int GS_AllocHWSurface(_THIS, SDL_Surface *surface)
581	{
582	return(-1);
583	}
584	static void GS_FreeHWSurface(_THIS, SDL_Surface *surface)
585	{
586	return;
587	}
588	static int GS_LockHWSurface(_THIS, SDL_Surface *surface)
589	{
590	if ( surface == this->screen ) {
591	/* Since mouse motion affects 'pixels', lock it */
592	SDL_LockCursor();
593
594	/* Make sure any pending DMA has completed */
595	if ( dma_pending ) {
596	ioctl(console_fd, PS2IOC_SENDQCT, 1);
597	dma_pending = 0;
598	}
599
600	/* If the cursor is drawn on the DMA area, remove it */
601	if ( cursor_drawn ) {
602	surface->pixels = mapped_mem + surface->offset;
603	SDL_EraseCursorNoLock(this->screen);
604	cursor_drawn = 0;
605	}
606
607	/* Set the surface pixels to the base of the DMA area */
608	surface->pixels = mapped_mem;
609
610	/* We're finished! */
611	SDL_UnlockCursor();
612	}
613	return(0);
614	}
615	static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface)
616	{
617	if ( surface == this->screen ) {
618	/* Since mouse motion affects 'pixels', lock it */
619	SDL_LockCursor();
620	surface->pixels = NULL;
621	SDL_UnlockCursor();
622	}
623	}
624
625	static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects)
626	{
627	/* Lock so we aren't interrupted by a mouse update */
628	SDL_LockCursor();
629
630	/* Make sure any pending DMA has completed */
631	if ( dma_pending ) {
632	ioctl(console_fd, PS2IOC_SENDQCT, 1);
633	dma_pending = 0;
634	}
635
636	/* If the mouse is visible, draw it on the DMA area */
637	if ( (SDL_cursorstate & CURSOR_VISIBLE) && !cursor_drawn ) {
638	this->screen->pixels = mapped_mem + this->screen->offset;
639	SDL_DrawCursorNoLock(this->screen);
640	this->screen->pixels = NULL;
641	cursor_drawn = 1;
642	}
643
644	/* Put the image onto the screen */
645	loadimage_nonblock(console_fd,
646	&screen_image, screen_image_size,
647	head_tags_mem, image_tags_mem);
648	if ( screen_image.y > 0 ) {
649	/* Need to scale offscreen image to TV output */
650	ioctl(console_fd, PS2IOC_SENDQCT, 1);
651	dma_pending = 0;
652	scaleimage_nonblock(console_fd, tex_tags_mem, scale_tags_mem);
653	} else {
654	dma_pending = 1;
655	}
656
657	/* We're finished! */
658	SDL_UnlockCursor();
659	}
660
661	static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
662	{
663	return(0);
664	}
665
666	static void GS_VideoQuit(_THIS)
667	{
668	/* Close console and input file descriptors */
669	if ( console_fd > 0 ) {
670	/* Unmap the video framebuffer */
671	if ( mapped_mem ) {
672	/* Unmap the video framebuffer */
673	munmap(mapped_mem, mapped_len);
674	mapped_mem = NULL;
675	}
676	close(memory_fd);
677
678	/* Restore the original video mode */
679	if ( GS_InGraphicsMode(this) ) {
680	ioctl(console_fd, PS2IOC_SSCREENINFO, &saved_vinfo);
681	}
682
683	/* We're all done with the graphics device */
684	close(console_fd);
685	console_fd = -1;
686	}
687	GS_CloseMouse(this);
688	GS_CloseKeyboard(this);
689	}