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

#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
        {
            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;
}

/* vi: set ts=4 sw=4 expandtab: */