/* $XFree86: xc/lib/Xxf86dga/XF86DGA.c,v 3.19 2001/08/18 02:41:30 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

#if defined(linux)

#define HAS_MMAP_ANON

#include <sys/types.h>

#include <sys/mman.h>

#include <asm/page.h> /* PAGE_SIZE */

#define HAS_SC_PAGESIZE /* _SC_PAGESIZE may be an enum for Linux */

#define HAS_GETPAGESIZE

#endif /* linux */

#if defined(CSRG_BASED)

#define HAS_MMAP_ANON

#define HAS_GETPAGESIZE

#include <sys/types.h>

#include <sys/mman.h>

#endif /* CSRG_BASED */

#if defined(DGUX)

#define HAS_GETPAGESIZE

#define MMAP_DEV_ZERO

#include <sys/types.h>

#include <sys/mman.h>

#include <unistd.h>

#endif /* DGUX */

#if defined(SVR4) && !defined(DGUX)

#define MMAP_DEV_ZERO

#include <sys/types.h>

#include <sys/mman.h>

#include <unistd.h>

#endif /* SVR4 && !DGUX */

#if defined(sun) && !defined(SVR4) /* SunOS */

#define MMAP_DEV_ZERO /* doesn't SunOS have MAP_ANON ?? */

#define HAS_GETPAGESIZE

#include <sys/types.h>

#include <sys/mman.h>

#endif /* sun && !SVR4 */

#ifdef XNO_SYSCONF

#undef _SC_PAGESIZE

#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"

extern XExtDisplayInfo* SDL_NAME(xdga_find_display)(Display*);

extern char *SDL_NAME(xdga_extension_name);

#define XF86DGACheckExtension(dpy,i,val) \

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

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

* *

* public XFree86-DGA Extension routines *

* *

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

Bool SDL_NAME(XF86DGAQueryExtension) (

Display *dpy,

int *event_basep,

int *error_basep

){

return SDL_NAME(XDGAQueryExtension)(dpy, event_basep, error_basep);

}

Bool SDL_NAME(XF86DGAQueryVersion)(

Display* dpy,

int* majorVersion,

int* minorVersion

){

return SDL_NAME(XDGAQueryVersion)(dpy, majorVersion, minorVersion);

}

Bool SDL_NAME(XF86DGAGetVideoLL)(

Display* dpy,

int screen,

int *offset,

int *width,

int *bank_size,

int *ram_size

){

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

xXF86DGAGetVideoLLReply rep;

xXF86DGAGetVideoLLReq *req;

XF86DGACheckExtension (dpy, info, False);

LockDisplay(dpy);

GetReq(XF86DGAGetVideoLL, req);

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

req->dgaReqType = X_XF86DGAGetVideoLL;

req->screen = screen;

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

UnlockDisplay(dpy);

SyncHandle();

return False;

}

*offset = /*(char *)*/rep.offset;

*width = rep.width;

*bank_size = rep.bank_size;

*ram_size = rep.ram_size;

UnlockDisplay(dpy);

SyncHandle();

return True;

}

Bool SDL_NAME(XF86DGADirectVideoLL)(

Display* dpy,

int screen,

int enable

){

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

xXF86DGADirectVideoReq *req;

XF86DGACheckExtension (dpy, info, False);

LockDisplay(dpy);

GetReq(XF86DGADirectVideo, req);

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

req->dgaReqType = X_XF86DGADirectVideo;

req->screen = screen;

req->enable = enable;

UnlockDisplay(dpy);

SyncHandle();

XSync(dpy,False);

return True;

}

Bool SDL_NAME(XF86DGAGetViewPortSize)(

Display* dpy,

int screen,

int *width,

int *height

){

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

xXF86DGAGetViewPortSizeReply rep;

xXF86DGAGetViewPortSizeReq *req;

XF86DGACheckExtension (dpy, info, False);

LockDisplay(dpy);

GetReq(XF86DGAGetViewPortSize, req);

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

req->dgaReqType = X_XF86DGAGetViewPortSize;

req->screen = screen;

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

UnlockDisplay(dpy);

SyncHandle();

return False;

}

*width = rep.width;

*height = rep.height;

UnlockDisplay(dpy);

SyncHandle();

return True;

}

Bool SDL_NAME(XF86DGASetViewPort)(

Display* dpy,

int screen,

int x,

int y

){

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

xXF86DGASetViewPortReq *req;

XF86DGACheckExtension (dpy, info, False);

LockDisplay(dpy);

GetReq(XF86DGASetViewPort, req);

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

req->dgaReqType = X_XF86DGASetViewPort;

req->screen = screen;

req->x = x;

req->y = y;

UnlockDisplay(dpy);

SyncHandle();

XSync(dpy,False);

return True;

}

Bool SDL_NAME(XF86DGAGetVidPage)(

Display* dpy,

int screen,

int *vpage

){

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

xXF86DGAGetVidPageReply rep;

xXF86DGAGetVidPageReq *req;

XF86DGACheckExtension (dpy, info, False);

LockDisplay(dpy);

GetReq(XF86DGAGetVidPage, req);

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

req->dgaReqType = X_XF86DGAGetVidPage;

req->screen = screen;

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

UnlockDisplay(dpy);

SyncHandle();

return False;

}

*vpage = rep.vpage;

UnlockDisplay(dpy);

SyncHandle();

return True;

}

Bool SDL_NAME(XF86DGASetVidPage)(

Display* dpy,

int screen,

int vpage

){

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

xXF86DGASetVidPageReq *req;

XF86DGACheckExtension (dpy, info, False);

LockDisplay(dpy);

GetReq(XF86DGASetVidPage, req);

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

req->dgaReqType = X_XF86DGASetVidPage;

req->screen = screen;

req->vpage = vpage;

UnlockDisplay(dpy);

SyncHandle();

XSync(dpy,False);

return True;

}

Bool SDL_NAME(XF86DGAInstallColormap)(

Display* dpy,

int screen,

Colormap cmap

){

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

xXF86DGAInstallColormapReq *req;

XF86DGACheckExtension (dpy, info, False);

LockDisplay(dpy);

GetReq(XF86DGAInstallColormap, req);

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

req->dgaReqType = X_XF86DGAInstallColormap;

req->screen = screen;

req->id = cmap;

UnlockDisplay(dpy);

SyncHandle();

XSync(dpy,False);

return True;

}

Bool SDL_NAME(XF86DGAQueryDirectVideo)(

Display *dpy,

int screen,

int *flags

){

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

xXF86DGAQueryDirectVideoReply rep;

xXF86DGAQueryDirectVideoReq *req;

XF86DGACheckExtension (dpy, info, False);

LockDisplay(dpy);

GetReq(XF86DGAQueryDirectVideo, req);

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

req->dgaReqType = X_XF86DGAQueryDirectVideo;

req->screen = screen;

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

UnlockDisplay(dpy);

SyncHandle();

return False;

}

*flags = rep.flags;

UnlockDisplay(dpy);

SyncHandle();

return True;

}

Bool SDL_NAME(XF86DGAViewPortChanged)(

Display *dpy,

int screen,

int n

){

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

xXF86DGAViewPortChangedReply rep;

xXF86DGAViewPortChangedReq *req;

XF86DGACheckExtension (dpy, info, False);

LockDisplay(dpy);

GetReq(XF86DGAViewPortChanged, req);

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

req->dgaReqType = X_XF86DGAViewPortChanged;

req->screen = screen;

req->n = n;

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

UnlockDisplay(dpy);

SyncHandle();

return False;

}

UnlockDisplay(dpy);

SyncHandle();

return rep.result;

}

/* Helper functions */

#include <X11/Xmd.h>

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

#include <stdlib.h>

#include <stdio.h>

#include <fcntl.h>

#if defined(ISC)

# define HAS_SVR3_MMAP

# include <sys/types.h>

# include <errno.h>

# include <sys/at_ansi.h>

# include <sys/kd.h>

# include <sys/sysmacros.h>

# include <sys/immu.h>

# include <sys/region.h>

# include <sys/mmap.h>

#else

# if !defined(Lynx)

# if !defined(__EMX__)

# include <sys/mman.h>

# endif

# else

# include <sys/types.h>

# include <errno.h>

# include <smem.h>

# endif

#endif

#include <sys/wait.h>

#include <signal.h>

#include <unistd.h>

#if defined(SVR4) && !defined(sun) && !defined(SCO325)

#define DEV_MEM "/dev/pmem"

#elif defined(SVR4) && defined(sun)

#define DEV_MEM "/dev/xsvc"

#else

#define DEV_MEM "/dev/mem"

#endif

typedef struct {

unsigned long physaddr; /* actual requested physical address */

unsigned long size; /* actual requested map size */

unsigned long delta; /* delta to account for page alignment */

void * vaddr; /* mapped address, without the delta */

int refcount; /* reference count */

} MapRec, *MapPtr;

typedef struct {

Display * display;

int screen;

MapPtr map;

} ScrRec, *ScrPtr;

static int mapFd = -1;

static int numMaps = 0;

static int numScrs = 0;

static MapPtr *mapList = NULL;

static ScrPtr *scrList = NULL;

static MapPtr

AddMap(void)

{

MapPtr *old;

old = mapList;

mapList = realloc(mapList, sizeof(MapPtr) * (numMaps + 1));

if (!mapList) {

mapList = old;

return NULL;

}

mapList[numMaps] = malloc(sizeof(MapRec));

if (!mapList[numMaps])

return NULL;

return mapList[numMaps++];

}

static ScrPtr

AddScr(void)

{

ScrPtr *old;

old = scrList;

scrList = realloc(scrList, sizeof(ScrPtr) * (numScrs + 1));

if (!scrList) {

scrList = old;

return NULL;

}

scrList[numScrs] = malloc(sizeof(ScrRec));

if (!scrList[numScrs])

return NULL;

return scrList[numScrs++];

}

static MapPtr

FindMap(unsigned long address, unsigned long size)

{

int i;

for (i = 0; i < numMaps; i++) {

if (mapList[i]->physaddr == address &&

mapList[i]->size == size)

return mapList[i];

}

return NULL;

}

static ScrPtr

FindScr(Display *display, int screen)

{

int i;

for (i = 0; i < numScrs; i++) {

if (scrList[i]->display == display &&

scrList[i]->screen == screen)

return scrList[i];

}

return NULL;

}

static void *

MapPhysAddress(unsigned long address, unsigned long size)

{

unsigned long offset, delta;

int pagesize = -1;

void *vaddr;

MapPtr mp;

#if defined(ISC) && defined(HAS_SVR3_MMAP)

struct kd_memloc mloc;

#elif defined(__EMX__)

APIRET rc;

ULONG action;

HFILE hfd;

#endif

if ((mp = FindMap(address, size))) {

mp->refcount++;

return (void *)((unsigned long)mp->vaddr + mp->delta);

}

#if defined(_SC_PAGESIZE) && defined(HAS_SC_PAGESIZE)

pagesize = sysconf(_SC_PAGESIZE);

#endif

#ifdef _SC_PAGE_SIZE

if (pagesize == -1)

pagesize = sysconf(_SC_PAGE_SIZE);

#endif

#ifdef HAS_GETPAGESIZE

if (pagesize == -1)

pagesize = getpagesize();

#endif

#ifdef PAGE_SIZE

if (pagesize == -1)

pagesize = PAGE_SIZE;

#endif

if (pagesize == -1)

pagesize = 4096;

delta = address % pagesize;

offset = address - delta;

#if defined(ISC) && defined(HAS_SVR3_MMAP)

if (mapFd < 0) {

if ((mapFd = open("/dev/mmap", O_RDWR)) < 0)

return NULL;

}

mloc.vaddr = (char *)0;

mloc.physaddr = (char *)offset;

mloc.length = size + delta;

mloc.ioflg=1;

if ((vaddr = (void *)ioctl(mapFd, MAP, &mloc)) == (void *)-1)

return NULL;

#elif defined (__EMX__)

/*

* Dragon warning here! /dev/pmap$ is never closed, except on progam exit.

* Consecutive calling of this routine will make PMAP$ driver run out

* of memory handles. Some umap/close mechanism should be provided

*/

rc = DosOpen("/dev/pmap$", &hfd, &action, 0, FILE_NORMAL, FILE_OPEN,

OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE, (PEAOP2)NULL);

if (rc != 0)

return NULL;

{

struct map_ioctl {

} pmap,dmap;

ULONG plen,dlen;

#define XFREE86_PMAP 0x76

#define PMAP_MAP 0x44

pmap.a.phys = offset;

pmap.size = size + delta;

rc = DosDevIOCtl(hfd, XFREE86_PMAP, PMAP_MAP,

(PULONG)&pmap, sizeof(pmap), &plen,

(PULONG)&dmap, sizeof(dmap), &dlen);

if (rc == 0) {

vaddr = dmap.a.user;

}

}

if (rc != 0)

return NULL;

#elif defined (Lynx)

vaddr = (void *)smem_create("XF86DGA", (char *)offset,

size + delta, SM_READ|SM_WRITE);

#else

#ifndef MAP_FILE

#define MAP_FILE 0

#endif

if (mapFd < 0) {

if ((mapFd = open(DEV_MEM, O_RDWR)) < 0)

return NULL;

}

vaddr = (void *)mmap(NULL, size + delta, PROT_READ | PROT_WRITE,

MAP_FILE | MAP_SHARED, mapFd, (off_t)offset);

if (vaddr == (void *)-1)

return NULL;

#endif

if (!vaddr) {

if (!(mp = AddMap()))

return NULL;

mp->physaddr = address;

mp->size = size;

mp->delta = delta;

mp->vaddr = vaddr;

mp->refcount = 1;

}

return (void *)((unsigned long)vaddr + delta);

}

/*

* Still need to find a clean way of detecting the death of a DGA app

* and returning things to normal - Jon

* This is here to help debugging without rebooting... Also C-A-BS

* should restore text mode.

*/

int

SDL_NAME(XF86DGAForkApp)(int screen)

{

pid_t pid;

int status;

int i;

/* fork the app, parent hangs around to clean up */

if ((pid = fork()) > 0) {

ScrPtr sp;

waitpid(pid, &status, 0);

for (i = 0; i < numScrs; i++) {

sp = scrList[i];

SDL_NAME(XF86DGADirectVideoLL)(sp->display, sp->screen, 0);

XSync(sp->display, False);

}

if (WIFEXITED(status))

_exit(0);

else

_exit(-1);

}

return pid;

}

Bool

SDL_NAME(XF86DGADirectVideo)(

Display *dis,

int screen,

int enable

){

ScrPtr sp;

MapPtr mp = NULL;

if ((sp = FindScr(dis, screen)))

mp = sp->map;

if (enable & XF86DGADirectGraphics) {

#if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \

&& !defined(__EMX__)

if (mp && mp->vaddr)

mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ | PROT_WRITE);

#endif

} else {

#if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \

&& !defined(__EMX__)

if (mp && mp->vaddr)

mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ);

#elif defined(Lynx)

/* XXX this doesn't allow enable after disable */

smem_create(NULL, mp->vaddr, mp->size + mp->delta, SM_DETACH);

smem_remove("XF86DGA");

#endif

}

SDL_NAME(XF86DGADirectVideoLL)(dis, screen, enable);

return 1;

}

static void

XF86cleanup(int sig)

{

ScrPtr sp;

int i;

static char beenhere = 0;

if (beenhere)

_exit(3);

beenhere = 1;

for (i = 0; i < numScrs; i++) {

sp = scrList[i];

SDL_NAME(XF86DGADirectVideo)(sp->display, sp->screen, 0);

XSync(sp->display, False);

}

_exit(3);

}

Bool

SDL_NAME(XF86DGAGetVideo)(

Display *dis,

int screen,

char **addr,

int *width,

int *bank,

int *ram

){

/*unsigned long*/ int offset;

static int beenHere = 0;

ScrPtr sp;

MapPtr mp;

if (!(sp = FindScr(dis, screen))) {

if (!(sp = AddScr())) {

fprintf(stderr, "XF86DGAGetVideo: malloc failure\n");

exit(-2);

}

sp->display = dis;

sp->screen = screen;

sp->map = NULL;

}

SDL_NAME(XF86DGAGetVideoLL)(dis, screen , &offset, width, bank, ram);

*addr = MapPhysAddress(offset, *bank);

if (*addr == NULL) {

fprintf(stderr, "XF86DGAGetVideo: failed to map video memory (%s)\n",

strerror(errno));

exit(-2);

}

if ((mp = FindMap(offset, *bank)))

sp->map = mp;

if (!beenHere) {

beenHere = 1;

atexit((void(*)(void))XF86cleanup);

/* one shot XF86cleanup attempts */

signal(SIGSEGV, XF86cleanup);

#ifdef SIGBUS

signal(SIGBUS, XF86cleanup);

#endif

signal(SIGHUP, XF86cleanup);

signal(SIGFPE, XF86cleanup);

}

return 1;

}