/* $XFree86: xc/lib/Xxf86dga/XF86DGA2.c,v 1.18 2001/08/17 13:27:51 dawes Exp $ */

/*

Copyright (c) 1995  Jon Tombs

Copyright (c) 1995,1996  The XFree86 Project, Inc

*/

/* THIS IS NOT AN X CONSORTIUM STANDARD */

#ifdef __EMX__ /* needed here to override certain constants in X headers */

#define INCL_DOS

#define INCL_DOSIOCTL

#include <os2.h>

#endif

#define NEED_EVENTS

#define NEED_REPLIES

#include <X11/Xlibint.h>

#include "../extensions/xf86dga.h"

#include "../extensions/xf86dgastr.h"

#include "../extensions/Xext.h"

#include "../extensions/extutil.h"

#include <stdio.h>

#if defined(ENABLE_FBCON)  /* Needed for framebuffer console support */

#include <sys/ioctl.h>

#include <linux/fb.h>

#endif

/* If you change this, change the Bases[] array below as well */

#define MAX_HEADS 16

char *SDL_NAME(xdga_extension_name) = XF86DGANAME;

static XExtensionInfo _xdga_info_data;

static XExtensionInfo *xdga_info = &_xdga_info_data;

Bool SDL_NAME(XDGAMapFramebuffer)(int, char *, unsigned char*, CARD32, CARD32, CARD32);

void SDL_NAME(XDGAUnmapFramebuffer)(int);

unsigned char* SDL_NAME(XDGAGetMappedMemory)(int);

#define XDGACheckExtension(dpy,i,val) \

  XextCheckExtension (dpy, i, SDL_NAME(xdga_extension_name), val)

/*****************************************************************************

 *                                                                           *

 *			   private utility routines                          *

 *                                                                           *

 *****************************************************************************/

static int xdga_close_display(Display *dpy, XExtCodes *codes);

static Bool xdga_wire_to_event(Display *dpy, XEvent *event, xEvent *wire_ev);

static Status xdga_event_to_wire(Display *dpy, XEvent *event, xEvent *wire_ev);

static XExtensionHooks xdga_extension_hooks = {

    NULL,				/* create_gc */

    NULL,				/* copy_gc */

    NULL,				/* flush_gc */

    NULL,				/* free_gc */

    NULL,				/* create_font */

    NULL,				/* free_font */

    xdga_close_display,			/* close_display */

    xdga_wire_to_event,			/* wire_to_event */

    xdga_event_to_wire,			/* event_to_wire */

    NULL,				/* error */

    NULL,				/* error_string */

};

static XEXT_GENERATE_CLOSE_DISPLAY (xdga_close_display, xdga_info)

XEXT_GENERATE_FIND_DISPLAY (SDL_NAME(xdga_find_display), xdga_info, 

				   "XFree86-DGA", 

				   &xdga_extension_hooks, 

				   0, NULL)

static Status

xdga_event_to_wire(

  Display *dpy,

  XEvent *event,

  xEvent *wire_ev

){

    return True;

}

static Bool

xdga_wire_to_event(

  Display *dpy,

  XEvent *event,

  xEvent *wire_ev

){

  dgaEvent *wire = (dgaEvent *) wire_ev;

  SDL_NAME(XDGAButtonEvent) *bevent;

  SDL_NAME(XDGAKeyEvent) *kevent;

  SDL_NAME(XDGAMotionEvent) *mevent;

  XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);

  XDGACheckExtension (dpy, info, False);

  switch((wire->u.u.type & 0x7f) - info->codes->first_event) {

  case MotionNotify:

	mevent = (SDL_NAME(XDGAMotionEvent)*)event;

	mevent->type = wire->u.u.type & 0x7F;

	mevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *)wire);

	mevent->display = dpy;

	mevent->screen = wire->u.event.screen;

	mevent->time = wire->u.event.time;

	mevent->state = wire->u.event.state;

	mevent->dx = wire->u.event.dx;

	mevent->dy = wire->u.event.dy;

	return True;

  case ButtonPress:

  case ButtonRelease:

	bevent = (SDL_NAME(XDGAButtonEvent)*)event;

	bevent->type = wire->u.u.type & 0x7F;

	bevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *)wire);

	bevent->display = dpy;

	bevent->screen = wire->u.event.screen;

	bevent->time = wire->u.event.time;

	bevent->state = wire->u.event.state;

	bevent->button = wire->u.u.detail;

	return True;

  case KeyPress:

  case KeyRelease:

	kevent = (SDL_NAME(XDGAKeyEvent)*)event;

	kevent->type = wire->u.u.type & 0x7F;

	kevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *)wire);

	kevent->display = dpy;

	kevent->screen = wire->u.event.screen;

	kevent->time = wire->u.event.time;

	kevent->state = wire->u.event.state;

	kevent->keycode = wire->u.u.detail;

	return True;

  }

  return False;

}

Bool SDL_NAME(XDGAQueryExtension) (

    Display *dpy,

    int *event_basep,

    int *error_basep

){

    XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);

    if (XextHasExtension(info)) {

	*event_basep = info->codes->first_event;

	*error_basep = info->codes->first_error;

	return True;

    } else {

	return False;

    }

}

Bool SDL_NAME(XDGAQueryVersion)(

    Display *dpy,

    int *majorVersion, 

    int *minorVersion

){

    XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);

    xXDGAQueryVersionReply rep;

    xXDGAQueryVersionReq *req;

    XDGACheckExtension (dpy, info, False);

    LockDisplay(dpy);

    GetReq(XDGAQueryVersion, req);

    req->reqType = info->codes->major_opcode;

    req->dgaReqType = X_XDGAQueryVersion;

    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

	UnlockDisplay(dpy);

	SyncHandle();

	return False;

    }

    *majorVersion = rep.majorVersion;

    *minorVersion = rep.minorVersion;

    UnlockDisplay(dpy);

    SyncHandle();

    if (*majorVersion >= 2)

    {

	int i, j;

	for (i = 0, j = info->codes->first_event;

	     i < XF86DGANumberEvents;

	     i++, j++) 

	{

	    XESetWireToEvent(dpy, j, xdga_wire_to_event);

	    XESetEventToWire(dpy, j, xdga_event_to_wire);

	}

	SDL_NAME(XDGASetClientVersion)(dpy);

    }

    return True;

}

Bool SDL_NAME(XDGASetClientVersion)(

    Display	*dpy

){

    XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);

    xXDGASetClientVersionReq *req;

    XDGACheckExtension (dpy, info, False);

    LockDisplay(dpy);

    GetReq(XDGASetClientVersion, req);

    req->reqType = info->codes->major_opcode;

    req->dgaReqType = X_XDGASetClientVersion;

    req->major = XDGA_MAJOR_VERSION;

    req->minor = XDGA_MINOR_VERSION;

    UnlockDisplay(dpy);

    SyncHandle();

    return True;

}

Bool SDL_NAME(XDGAOpenFramebuffer)(

    Display	*dpy,

    int 	screen

){

    XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);

    xXDGAOpenFramebufferReply rep;

    xXDGAOpenFramebufferReq *req;

    char *deviceName = NULL;

    Bool ret;

    XDGACheckExtension (dpy, info, False);

    LockDisplay(dpy);

    GetReq(XDGAOpenFramebuffer, req);

    req->reqType = info->codes->major_opcode;

    req->dgaReqType = X_XDGAOpenFramebuffer;

    req->screen = screen;

    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

	UnlockDisplay(dpy);

	SyncHandle();

	return False;

    }

    if(rep.length) {

	deviceName = Xmalloc(rep.length << 2);

	_XRead(dpy, deviceName, rep.length << 2);

    }

    ret = SDL_NAME(XDGAMapFramebuffer)(screen, deviceName,

				(unsigned char*)(long)rep.mem1, 

				rep.size, rep.offset, rep.extra);

    if(deviceName)

	Xfree(deviceName);	

    UnlockDisplay(dpy);

    SyncHandle();

    return ret;

}

void SDL_NAME(XDGACloseFramebuffer)(

    Display	*dpy,

    int		screen

){

    XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);

    xXDGACloseFramebufferReq *req;

    XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));

    SDL_NAME(XDGAUnmapFramebuffer)(screen);

    LockDisplay(dpy);

    GetReq(XDGACloseFramebuffer, req);

    req->reqType = info->codes->major_opcode;

    req->dgaReqType = X_XDGACloseFramebuffer;

    req->screen = screen;

    UnlockDisplay(dpy);

    SyncHandle();

}

SDL_NAME(XDGAMode)* SDL_NAME(XDGAQueryModes)(

    Display *dpy,

    int screen,

    int *num

){

    XExtDisplayInfo *dinfo = SDL_NAME(xdga_find_display) (dpy);

    xXDGAQueryModesReply rep;

    xXDGAQueryModesReq *req;

    SDL_NAME(XDGAMode) *modes = NULL;

    *num = 0;

    XDGACheckExtension (dpy, dinfo, NULL);

    LockDisplay(dpy);

    GetReq(XDGAQueryModes, req);

    req->reqType = dinfo->codes->major_opcode;

    req->dgaReqType = X_XDGAQueryModes;

    req->screen = screen;

    if (_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

	if(rep.length) {

	   xXDGAModeInfo info;

	   int i, size;

	   char *offset;

	   size = rep.length << 2;

	   size -= rep.number * sz_xXDGAModeInfo; /* find text size */

	   modes = (SDL_NAME(XDGAMode)*)Xmalloc((rep.number * sizeof(SDL_NAME(XDGAMode))) + size);

	   offset = (char*)(&modes[rep.number]); /* start of text */

	   if(modes) {	

	      for(i = 0; i < rep.number; i++) {

		_XRead(dpy, (char*)(&info), sz_xXDGAModeInfo);

		modes[i].num = info.num;

		modes[i].verticalRefresh = 

			(float)info.vsync_num / (float)info.vsync_den;

		modes[i].flags = info.flags;

		modes[i].imageWidth = info.image_width;

		modes[i].imageHeight = info.image_height;

		modes[i].pixmapWidth = info.pixmap_width;

		modes[i].pixmapHeight = info.pixmap_height;

		modes[i].bytesPerScanline = info.bytes_per_scanline;

		modes[i].byteOrder = info.byte_order;

		modes[i].depth = info.depth;

		modes[i].bitsPerPixel = info.bpp;

		modes[i].redMask = info.red_mask;

		modes[i].greenMask = info.green_mask;

		modes[i].blueMask = info.blue_mask;

		modes[i].visualClass = info.visual_class;

		modes[i].viewportWidth = info.viewport_width;

		modes[i].viewportHeight = info.viewport_height;

		modes[i].xViewportStep = info.viewport_xstep;

		modes[i].yViewportStep = info.viewport_ystep;

		modes[i].maxViewportX = info.viewport_xmax;

		modes[i].maxViewportY = info.viewport_ymax;

		modes[i].viewportFlags = info.viewport_flags;

		modes[i].reserved1 = info.reserved1;

		modes[i].reserved2 = info.reserved2;	

		_XRead(dpy, offset, info.name_size);

		modes[i].name = offset;

		offset += info.name_size;

	      }

	      *num = rep.number;

	   } else

		_XEatData(dpy, rep.length << 2);

	}

    }

    UnlockDisplay(dpy);

    SyncHandle();

    return modes;

}

SDL_NAME(XDGADevice) * 

SDL_NAME(XDGASetMode)(

    Display	*dpy,

    int		screen,

    int		mode

){

    XExtDisplayInfo *dinfo = SDL_NAME(xdga_find_display) (dpy);

    xXDGASetModeReply rep;

    xXDGASetModeReq *req;

    SDL_NAME(XDGADevice) *dev = NULL;

    Pixmap pid;

    XDGACheckExtension (dpy, dinfo, NULL);

    LockDisplay(dpy);

    GetReq(XDGASetMode, req);

    req->reqType = dinfo->codes->major_opcode;

    req->dgaReqType = X_XDGASetMode;

    req->screen = screen;

    req->mode = mode;

    req->pid = pid = XAllocID(dpy);

    if (_XReply(dpy, (xReply *)&rep, 0, xFalse)) {

	if(rep.length) {

	   xXDGAModeInfo info;

	   int size;

	   size = rep.length << 2;

	   size -= sz_xXDGAModeInfo; /* get text size */

	   dev = (SDL_NAME(XDGADevice)*)Xmalloc(sizeof(SDL_NAME(XDGADevice)) + size);

	   if(dev) {

		_XRead(dpy, (char*)(&info), sz_xXDGAModeInfo);

		dev->mode.num = info.num;

		dev->mode.verticalRefresh = 

				(float)info.vsync_num / (float)info.vsync_den;

		dev->mode.flags = info.flags;

		dev->mode.imageWidth = info.image_width;

		dev->mode.imageHeight = info.image_height;

		dev->mode.pixmapWidth = info.pixmap_width;

		dev->mode.pixmapHeight = info.pixmap_height;

		dev->mode.bytesPerScanline = info.bytes_per_scanline;

		dev->mode.byteOrder = info.byte_order;

		dev->mode.depth = info.depth;

		dev->mode.bitsPerPixel = info.bpp;

		dev->mode.redMask = info.red_mask;

		dev->mode.greenMask = info.green_mask;

		dev->mode.blueMask = info.blue_mask;

		dev->mode.visualClass = info.visual_class;

		dev->mode.viewportWidth = info.viewport_width;

		dev->mode.viewportHeight = info.viewport_height;

		dev->mode.xViewportStep = info.viewport_xstep;

		dev->mode.yViewportStep = info.viewport_ystep;

		dev->mode.maxViewportX = info.viewport_xmax;

		dev->mode.maxViewportY = info.viewport_ymax;

		dev->mode.viewportFlags = info.viewport_flags;

		dev->mode.reserved1 = info.reserved1;

		dev->mode.reserved2 = info.reserved2;

		dev->mode.name = (char*)(&dev[1]);	

		_XRead(dpy, dev->mode.name, info.name_size);

		dev->pixmap = (rep.flags & XDGAPixmap) ? pid : 0;

		dev->data = SDL_NAME(XDGAGetMappedMemory)(screen);

		if(dev->data)

		    dev->data += rep.offset;

	   } 

	   /* not sure what to do if the allocation fails */

	}

    }

    UnlockDisplay(dpy);

    SyncHandle();

    return dev;

}

void SDL_NAME(XDGASetViewport)(

    Display	*dpy,

    int		screen,

    int		x,

    int		y,

    int		flags

){

    XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);

    xXDGASetViewportReq *req;

    XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));

    LockDisplay(dpy);

    GetReq(XDGASetViewport, req);

    req->reqType = info->codes->major_opcode;

    req->dgaReqType = X_XDGASetViewport;

    req->screen = screen;

    req->x = x;

    req->y = y;

    req->flags = flags;

    UnlockDisplay(dpy);

    SyncHandle();

}

void SDL_NAME(XDGAInstallColormap)(

    Display	*dpy,

    int		screen,

    Colormap	cmap

){

    XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);

    xXDGAInstallColormapReq *req;

    XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));

    LockDisplay(dpy);

    GetReq(XDGAInstallColormap, req);

    req->reqType = info->codes->major_opcode;

    req->dgaReqType = X_XDGAInstallColormap;

    req->screen = screen;

    req->cmap = cmap;

    UnlockDisplay(dpy);

    SyncHandle();

}

void SDL_NAME(XDGASelectInput)(

    Display	*dpy,

    int		screen,

    long	mask

){

    XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);

    xXDGASelectInputReq *req;

    XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));

    LockDisplay(dpy);

    GetReq(XDGASelectInput, req);

    req->reqType = info->codes->major_opcode;

    req->dgaReqType = X_XDGASelectInput;

    req->screen = screen;

    req->mask = mask;

    UnlockDisplay(dpy);

    SyncHandle();

}

void SDL_NAME(XDGAFillRectangle)(

    Display	*dpy,

    int		screen,

    int		x,

    int		y,

    unsigned int	width,

    unsigned int	height,

    unsigned long	color

){

    XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);

    xXDGAFillRectangleReq *req;

    XextSimpleCheckExtension (dpy, info, SDL_NAME(xdga_extension_name));

    LockDisplay(dpy);

    GetReq(XDGAFillRectangle, req);

    req->reqType = info->codes->major_opcode;

    req->dgaReqType = X_XDGAFillRectangle;

    req->screen = screen;

    req->x = x;

    req->y = y;

    req->width = width;