[sdl_omap.git] / src / video / Xext / Xxf86dga / XF86DGA.c

/* $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

/* Apparently some X11 systems can't include this multiple times... */
#ifndef SDL_INCLUDED_XLIBINT_H
#define SDL_INCLUDED_XLIBINT_H 1
#include <X11/Xlibint.h>
#endif

#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 {
		union {
			ULONG phys;
			void* user;
		} a;
		ULONG size;
	} 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;
}
Commit	Line	Data
e14743d1	1	/* $XFree86: xc/lib/Xxf86dga/XF86DGA.c,v 3.19 2001/08/18 02:41:30 dawes Exp $ */
	2	/*
	3
	4	Copyright (c) 1995 Jon Tombs
	5	Copyright (c) 1995,1996 The XFree86 Project, Inc
	6
	7	*/
	8
	9	/* THIS IS NOT AN X CONSORTIUM STANDARD */
	10
	11	#ifdef __EMX__ /* needed here to override certain constants in X headers */
	12	#define INCL_DOS
	13	#define INCL_DOSIOCTL
	14	#include <os2.h>
	15	#endif
	16
	17	#if defined(linux)
	18	#define HAS_MMAP_ANON
	19	#include <sys/types.h>
	20	#include <sys/mman.h>
	21	/#include <asm/page.h>/ /* PAGE_SIZE */
	22	#define HAS_SC_PAGESIZE /* _SC_PAGESIZE may be an enum for Linux */
	23	#define HAS_GETPAGESIZE
	24	#endif /* linux */
	25
	26	#if defined(CSRG_BASED)
	27	#define HAS_MMAP_ANON
	28	#define HAS_GETPAGESIZE
	29	#include <sys/types.h>
	30	#include <sys/mman.h>
	31	#endif /* CSRG_BASED */
	32
	33	#if defined(DGUX)
	34	#define HAS_GETPAGESIZE
	35	#define MMAP_DEV_ZERO
	36	#include <sys/types.h>
	37	#include <sys/mman.h>
	38	#include <unistd.h>
	39	#endif /* DGUX */
	40
	41	#if defined(SVR4) && !defined(DGUX)
	42	#define MMAP_DEV_ZERO
	43	#include <sys/types.h>
	44	#include <sys/mman.h>
	45	#include <unistd.h>
	46	#endif /* SVR4 && !DGUX */
	47
	48	#if defined(sun) && !defined(SVR4) /* SunOS */
	49	#define MMAP_DEV_ZERO /* doesn't SunOS have MAP_ANON ?? */
	50	#define HAS_GETPAGESIZE
	51	#include <sys/types.h>
	52	#include <sys/mman.h>
	53	#endif /* sun && !SVR4 */
	54
	55	#ifdef XNO_SYSCONF
	56	#undef _SC_PAGESIZE
	57	#endif
	58
	59	#define NEED_EVENTS
	60	#define NEED_REPLIES
	61
	62	/* Apparently some X11 systems can't include this multiple times... */
	63	#ifndef SDL_INCLUDED_XLIBINT_H
	64	#define SDL_INCLUDED_XLIBINT_H 1
65	#include <X11/Xlibint.h>
66	#endif
67
68	#include "../extensions/xf86dga.h"
69	#include "../extensions/xf86dgastr.h"
70	#include "../extensions/Xext.h"
71	#include "../extensions/extutil.h"
72
73	extern XExtDisplayInfo* SDL_NAME(xdga_find_display)(Display*);
74	extern char *SDL_NAME(xdga_extension_name);
75
76	#define XF86DGACheckExtension(dpy,i,val) \
77	XextCheckExtension (dpy, i, SDL_NAME(xdga_extension_name), val)
78
79	/*****************************************************************************
80	* *
81	* public XFree86-DGA Extension routines *
82	* *
83	*****************************************************************************/
84
85	Bool SDL_NAME(XF86DGAQueryExtension) (
86	Display *dpy,
87	int *event_basep,
88	int *error_basep
89	){
90	return SDL_NAME(XDGAQueryExtension)(dpy, event_basep, error_basep);
91	}
92
93	Bool SDL_NAME(XF86DGAQueryVersion)(
94	Display* dpy,
95	int* majorVersion,
96	int* minorVersion
97	){
98	return SDL_NAME(XDGAQueryVersion)(dpy, majorVersion, minorVersion);
99	}
100
101	Bool SDL_NAME(XF86DGAGetVideoLL)(
102	Display* dpy,
103	int screen,
104	int *offset,
105	int *width,
106	int *bank_size,
107	int *ram_size
108	){
109	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
110	xXF86DGAGetVideoLLReply rep;
111	xXF86DGAGetVideoLLReq *req;
112
113	XF86DGACheckExtension (dpy, info, False);
114
115	LockDisplay(dpy);
116	GetReq(XF86DGAGetVideoLL, req);
117	req->reqType = info->codes->major_opcode;
118	req->dgaReqType = X_XF86DGAGetVideoLL;
119	req->screen = screen;
120	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
121	UnlockDisplay(dpy);
122	SyncHandle();
123	return False;
124	}
125
126	offset = /(char )/rep.offset;
127	*width = rep.width;
128	*bank_size = rep.bank_size;
129	*ram_size = rep.ram_size;
130
131	UnlockDisplay(dpy);
132	SyncHandle();
133	return True;
134	}
135
136
137	Bool SDL_NAME(XF86DGADirectVideoLL)(
138	Display* dpy,
139	int screen,
140	int enable
141	){
142	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
143	xXF86DGADirectVideoReq *req;
144
145	XF86DGACheckExtension (dpy, info, False);
146
147	LockDisplay(dpy);
148	GetReq(XF86DGADirectVideo, req);
149	req->reqType = info->codes->major_opcode;
150	req->dgaReqType = X_XF86DGADirectVideo;
151	req->screen = screen;
152	req->enable = enable;
153	UnlockDisplay(dpy);
154	SyncHandle();
155	XSync(dpy,False);
156	return True;
157	}
158
159	Bool SDL_NAME(XF86DGAGetViewPortSize)(
160	Display* dpy,
161	int screen,
162	int *width,
163	int *height
164	){
165	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
166	xXF86DGAGetViewPortSizeReply rep;
167	xXF86DGAGetViewPortSizeReq *req;
168
169	XF86DGACheckExtension (dpy, info, False);
170
171	LockDisplay(dpy);
172	GetReq(XF86DGAGetViewPortSize, req);
173	req->reqType = info->codes->major_opcode;
174	req->dgaReqType = X_XF86DGAGetViewPortSize;
175	req->screen = screen;
176	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
177	UnlockDisplay(dpy);
178	SyncHandle();
179	return False;
180	}
181
182	*width = rep.width;
183	*height = rep.height;
184
185	UnlockDisplay(dpy);
186	SyncHandle();
187	return True;
188	}
189
190
191	Bool SDL_NAME(XF86DGASetViewPort)(
192	Display* dpy,
193	int screen,
194	int x,
195	int y
196	){
197	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
198	xXF86DGASetViewPortReq *req;
199
200	XF86DGACheckExtension (dpy, info, False);
201
202	LockDisplay(dpy);
203	GetReq(XF86DGASetViewPort, req);
204	req->reqType = info->codes->major_opcode;
205	req->dgaReqType = X_XF86DGASetViewPort;
206	req->screen = screen;
207	req->x = x;
208	req->y = y;
209	UnlockDisplay(dpy);
210	SyncHandle();
211	XSync(dpy,False);
212	return True;
213	}
214
215
216	Bool SDL_NAME(XF86DGAGetVidPage)(
217	Display* dpy,
218	int screen,
219	int *vpage
220	){
221	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
222	xXF86DGAGetVidPageReply rep;
223	xXF86DGAGetVidPageReq *req;
224
225	XF86DGACheckExtension (dpy, info, False);
226
227	LockDisplay(dpy);
228	GetReq(XF86DGAGetVidPage, req);
229	req->reqType = info->codes->major_opcode;
230	req->dgaReqType = X_XF86DGAGetVidPage;
231	req->screen = screen;
232	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
233	UnlockDisplay(dpy);
234	SyncHandle();
235	return False;
236	}
237
238	*vpage = rep.vpage;
239	UnlockDisplay(dpy);
240	SyncHandle();
241	return True;
242	}
243
244
245	Bool SDL_NAME(XF86DGASetVidPage)(
246	Display* dpy,
247	int screen,
248	int vpage
249	){
250	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
251	xXF86DGASetVidPageReq *req;
252
253	XF86DGACheckExtension (dpy, info, False);
254
255	LockDisplay(dpy);
256	GetReq(XF86DGASetVidPage, req);
257	req->reqType = info->codes->major_opcode;
258	req->dgaReqType = X_XF86DGASetVidPage;
259	req->screen = screen;
260	req->vpage = vpage;
261	UnlockDisplay(dpy);
262	SyncHandle();
263	XSync(dpy,False);
264	return True;
265	}
266
267	Bool SDL_NAME(XF86DGAInstallColormap)(
268	Display* dpy,
269	int screen,
270	Colormap cmap
271	){
272	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
273	xXF86DGAInstallColormapReq *req;
274
275	XF86DGACheckExtension (dpy, info, False);
276
277	LockDisplay(dpy);
278	GetReq(XF86DGAInstallColormap, req);
279	req->reqType = info->codes->major_opcode;
280	req->dgaReqType = X_XF86DGAInstallColormap;
281	req->screen = screen;
282	req->id = cmap;
283	UnlockDisplay(dpy);
284	SyncHandle();
285	XSync(dpy,False);
286	return True;
287	}
288
289	Bool SDL_NAME(XF86DGAQueryDirectVideo)(
290	Display *dpy,
291	int screen,
292	int *flags
293	){
294	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
295	xXF86DGAQueryDirectVideoReply rep;
296	xXF86DGAQueryDirectVideoReq *req;
297
298	XF86DGACheckExtension (dpy, info, False);
299
300	LockDisplay(dpy);
301	GetReq(XF86DGAQueryDirectVideo, req);
302	req->reqType = info->codes->major_opcode;
303	req->dgaReqType = X_XF86DGAQueryDirectVideo;
304	req->screen = screen;
305	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
306	UnlockDisplay(dpy);
307	SyncHandle();
308	return False;
309	}
310	*flags = rep.flags;
311	UnlockDisplay(dpy);
312	SyncHandle();
313	return True;
314	}
315
316	Bool SDL_NAME(XF86DGAViewPortChanged)(
317	Display *dpy,
318	int screen,
319	int n
320	){
321	XExtDisplayInfo *info = SDL_NAME(xdga_find_display) (dpy);
322	xXF86DGAViewPortChangedReply rep;
323	xXF86DGAViewPortChangedReq *req;
324
325	XF86DGACheckExtension (dpy, info, False);
326
327	LockDisplay(dpy);
328	GetReq(XF86DGAViewPortChanged, req);
329	req->reqType = info->codes->major_opcode;
330	req->dgaReqType = X_XF86DGAViewPortChanged;
331	req->screen = screen;
332	req->n = n;
333	if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
334	UnlockDisplay(dpy);
335	SyncHandle();
336	return False;
337	}
338	UnlockDisplay(dpy);
339	SyncHandle();
340	return rep.result;
341	}
342
343
344
345	/* Helper functions */
346
347	#include <X11/Xmd.h>
348	#include "../extensions/xf86dga.h"
349	#include <stdlib.h>
350	#include <stdio.h>
351	#include <fcntl.h>
352	#if defined(ISC)
353	# define HAS_SVR3_MMAP
354	# include <sys/types.h>
355	# include <errno.h>
356
357	# include <sys/at_ansi.h>
358	# include <sys/kd.h>
359
360	# include <sys/sysmacros.h>
361	# include <sys/immu.h>
362	# include <sys/region.h>
363
364	# include <sys/mmap.h>
365	#else
366	# if !defined(Lynx)
367	# if !defined(__EMX__)
368	# include <sys/mman.h>
369	# endif
370	# else
371	# include <sys/types.h>
372	# include <errno.h>
373	# include <smem.h>
374	# endif
375	#endif
376	#include <sys/wait.h>
377	#include <signal.h>
378	#include <unistd.h>
379
380	#if defined(SVR4) && !defined(sun) && !defined(SCO325)
381	#define DEV_MEM "/dev/pmem"
382	#elif defined(SVR4) && defined(sun)
383	#define DEV_MEM "/dev/xsvc"
384	#else
385	#define DEV_MEM "/dev/mem"
386	#endif
387
388	typedef struct {
389	unsigned long physaddr; /* actual requested physical address */
390	unsigned long size; /* actual requested map size */
391	unsigned long delta; /* delta to account for page alignment */
392	void * vaddr; /* mapped address, without the delta */
393	int refcount; /* reference count */
394	} MapRec, *MapPtr;
395
396	typedef struct {
397	Display * display;
398	int screen;
399	MapPtr map;
400	} ScrRec, *ScrPtr;
401
402	static int mapFd = -1;
403	static int numMaps = 0;
404	static int numScrs = 0;
405	static MapPtr *mapList = NULL;
406	static ScrPtr *scrList = NULL;
407
408	static MapPtr
409	AddMap(void)
410	{
411	MapPtr *old;
412
413	old = mapList;
414	mapList = realloc(mapList, sizeof(MapPtr) * (numMaps + 1));
415	if (!mapList) {
416	mapList = old;
417	return NULL;
418	}
419	mapList[numMaps] = malloc(sizeof(MapRec));
420	if (!mapList[numMaps])
421	return NULL;
422	return mapList[numMaps++];
423	}
424
425	static ScrPtr
426	AddScr(void)
427	{
428	ScrPtr *old;
429
430	old = scrList;
431	scrList = realloc(scrList, sizeof(ScrPtr) * (numScrs + 1));
432	if (!scrList) {
433	scrList = old;
434	return NULL;
435	}
436	scrList[numScrs] = malloc(sizeof(ScrRec));
437	if (!scrList[numScrs])
438	return NULL;
439	return scrList[numScrs++];
440	}
441
442	static MapPtr
443	FindMap(unsigned long address, unsigned long size)
444	{
445	int i;
446
447	for (i = 0; i < numMaps; i++) {
448	if (mapList[i]->physaddr == address &&
449	mapList[i]->size == size)
450	return mapList[i];
451	}
452	return NULL;
453	}
454
455	static ScrPtr
456	FindScr(Display *display, int screen)
457	{
458	int i;
459
460	for (i = 0; i < numScrs; i++) {
461	if (scrList[i]->display == display &&
462	scrList[i]->screen == screen)
463	return scrList[i];
464	}
465	return NULL;
466	}
467
468	static void *
469	MapPhysAddress(unsigned long address, unsigned long size)
470	{
471	unsigned long offset, delta;
472	int pagesize = -1;
473	void *vaddr;
474	MapPtr mp;
475	#if defined(ISC) && defined(HAS_SVR3_MMAP)
476	struct kd_memloc mloc;
477	#elif defined(__EMX__)
478	APIRET rc;
479	ULONG action;
480	HFILE hfd;
481	#endif
482
483	if ((mp = FindMap(address, size))) {
484	mp->refcount++;
485	return (void *)((unsigned long)mp->vaddr + mp->delta);
486	}
487
488	#if defined(_SC_PAGESIZE) && defined(HAS_SC_PAGESIZE)
489	pagesize = sysconf(_SC_PAGESIZE);
490	#endif
491	#ifdef _SC_PAGE_SIZE
492	if (pagesize == -1)
493	pagesize = sysconf(_SC_PAGE_SIZE);
494	#endif
495	#ifdef HAS_GETPAGESIZE
496	if (pagesize == -1)
497	pagesize = getpagesize();
498	#endif
499	#ifdef PAGE_SIZE
500	if (pagesize == -1)
501	pagesize = PAGE_SIZE;
502	#endif
503	if (pagesize == -1)
504	pagesize = 4096;
505
506	delta = address % pagesize;
507	offset = address - delta;
508
509	#if defined(ISC) && defined(HAS_SVR3_MMAP)
510	if (mapFd < 0) {
511	if ((mapFd = open("/dev/mmap", O_RDWR)) < 0)
512	return NULL;
513	}
514	mloc.vaddr = (char *)0;
515	mloc.physaddr = (char *)offset;
516	mloc.length = size + delta;
517	mloc.ioflg=1;
518
519	if ((vaddr = (void )ioctl(mapFd, MAP, &mloc)) == (void )-1)
520	return NULL;
521	#elif defined (__EMX__)
522	/*
523	* Dragon warning here! /dev/pmap$ is never closed, except on progam exit.
524	* Consecutive calling of this routine will make PMAP$ driver run out
525	* of memory handles. Some umap/close mechanism should be provided
526	*/
527
528	rc = DosOpen("/dev/pmap$", &hfd, &action, 0, FILE_NORMAL, FILE_OPEN,
529	OPEN_ACCESS_READWRITE \| OPEN_SHARE_DENYNONE, (PEAOP2)NULL);
530	if (rc != 0)
531	return NULL;
532	{
533	struct map_ioctl {
534	union {
535	ULONG phys;
536	void* user;
537	} a;
538	ULONG size;
539	} pmap,dmap;
540	ULONG plen,dlen;
541	#define XFREE86_PMAP 0x76
542	#define PMAP_MAP 0x44
543
544	pmap.a.phys = offset;
545	pmap.size = size + delta;
546	rc = DosDevIOCtl(hfd, XFREE86_PMAP, PMAP_MAP,
547	(PULONG)&pmap, sizeof(pmap), &plen,
548	(PULONG)&dmap, sizeof(dmap), &dlen);
549	if (rc == 0) {
550	vaddr = dmap.a.user;
551	}
552	}
553	if (rc != 0)
554	return NULL;
555	#elif defined (Lynx)
556	vaddr = (void )smem_create("XF86DGA", (char )offset,
557	size + delta, SM_READ\|SM_WRITE);
558	#else
559	#ifndef MAP_FILE
560	#define MAP_FILE 0
561	#endif
562	if (mapFd < 0) {
563	if ((mapFd = open(DEV_MEM, O_RDWR)) < 0)
564	return NULL;
565	}
566	vaddr = (void *)mmap(NULL, size + delta, PROT_READ \| PROT_WRITE,
567	MAP_FILE \| MAP_SHARED, mapFd, (off_t)offset);
568	if (vaddr == (void *)-1)
569	return NULL;
570	#endif
571
572	if (!vaddr) {
573	if (!(mp = AddMap()))
574	return NULL;
575	mp->physaddr = address;
576	mp->size = size;
577	mp->delta = delta;
578	mp->vaddr = vaddr;
579	mp->refcount = 1;
580	}
581	return (void *)((unsigned long)vaddr + delta);
582	}
583
584	/*
585	* Still need to find a clean way of detecting the death of a DGA app
586	* and returning things to normal - Jon
587	* This is here to help debugging without rebooting... Also C-A-BS
588	* should restore text mode.
589	*/
590
591	int
592	SDL_NAME(XF86DGAForkApp)(int screen)
593	{
594	pid_t pid;
595	int status;
596	int i;
597
598	/* fork the app, parent hangs around to clean up */
599	if ((pid = fork()) > 0) {
600	ScrPtr sp;
601
602	waitpid(pid, &status, 0);
603	for (i = 0; i < numScrs; i++) {
604	sp = scrList[i];
605	SDL_NAME(XF86DGADirectVideoLL)(sp->display, sp->screen, 0);
606	XSync(sp->display, False);
607	}
608	if (WIFEXITED(status))
609	_exit(0);
610	else
611	_exit(-1);
612	}
613	return pid;
614	}
615
616
617	Bool
618	SDL_NAME(XF86DGADirectVideo)(
619	Display *dis,
620	int screen,
621	int enable
622	){
623	ScrPtr sp;
624	MapPtr mp = NULL;
625
626	if ((sp = FindScr(dis, screen)))
627	mp = sp->map;
628
629	if (enable & XF86DGADirectGraphics) {
630	#if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
631	&& !defined(__EMX__)
632	if (mp && mp->vaddr)
633	mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ \| PROT_WRITE);
634	#endif
635	} else {
636	#if !defined(ISC) && !defined(HAS_SVR3_MMAP) && !defined(Lynx) \
637	&& !defined(__EMX__)
638	if (mp && mp->vaddr)
639	mprotect(mp->vaddr, mp->size + mp->delta, PROT_READ);
640	#elif defined(Lynx)
641	/* XXX this doesn't allow enable after disable */
642	smem_create(NULL, mp->vaddr, mp->size + mp->delta, SM_DETACH);
643	smem_remove("XF86DGA");
644	#endif
645	}
646
647	SDL_NAME(XF86DGADirectVideoLL)(dis, screen, enable);
648	return 1;
649	}
650
651
652	static void
653	XF86cleanup(int sig)
654	{
655	ScrPtr sp;
656	int i;
657	static char beenhere = 0;
658
659	if (beenhere)
660	_exit(3);
661	beenhere = 1;
662
663	for (i = 0; i < numScrs; i++) {
664	sp = scrList[i];
665	SDL_NAME(XF86DGADirectVideo)(sp->display, sp->screen, 0);
666	XSync(sp->display, False);
667	}
668	_exit(3);
669	}
670
671	Bool
672	SDL_NAME(XF86DGAGetVideo)(
673	Display *dis,
674	int screen,
675	char **addr,
676	int *width,
677	int *bank,
678	int *ram
679	){
680	/unsigned long/ int offset;
681	static int beenHere = 0;
682	ScrPtr sp;
683	MapPtr mp;
684
685	if (!(sp = FindScr(dis, screen))) {
686	if (!(sp = AddScr())) {
687	fprintf(stderr, "XF86DGAGetVideo: malloc failure\n");
688	exit(-2);
689	}
690	sp->display = dis;
691	sp->screen = screen;
692	sp->map = NULL;
693	}
694
695	SDL_NAME(XF86DGAGetVideoLL)(dis, screen , &offset, width, bank, ram);
696
697	addr = MapPhysAddress(offset, bank);
698	if (*addr == NULL) {
699	fprintf(stderr, "XF86DGAGetVideo: failed to map video memory (%s)\n",
700	strerror(errno));
701	exit(-2);
702	}
703
704	if ((mp = FindMap(offset, *bank)))
705	sp->map = mp;
706
707	if (!beenHere) {
708	beenHere = 1;
709	atexit((void(*)(void))XF86cleanup);
710	/* one shot XF86cleanup attempts */
711	signal(SIGSEGV, XF86cleanup);
712	#ifdef SIGBUS
713	signal(SIGBUS, XF86cleanup);
714	#endif
715	signal(SIGHUP, XF86cleanup);
716	signal(SIGFPE, XF86cleanup);
717	}
718
719	return 1;
720	}
721