/*
 * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany
 * Copyright 1993 by David Wexelblat <dwex@goblin.org>
 * Copyright 1999 by David Holland <davidh@iquest.net>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting documentation, and
 * that the names of the copyright holders not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  The copyright holders make no representations
 * about the suitability of this software for any purpose.  It is provided "as
 * is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT
 * SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 *
 */
/* Copyright (c) 2008, Oracle and/or its affiliates. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif

#include <sys/types.h> /* get __x86 definition if not set by compiler */

#if defined(__i386__) || defined(__i386) || defined(__x86)
# define _NEED_SYSI86
#endif
#include "xf86.h"
#include "xf86Priv.h"
#include "xf86_OSlib.h"
#include "xf86OSpriv.h"
#include <sys/mman.h>

/***************************************************************************/
/* Video Memory Mapping section 					   */
/***************************************************************************/

static char *apertureDevName = NULL;
static int apertureDevFD_ro = -1;
static int apertureDevFD_rw = -1;

static Bool
solOpenAperture(void)
{
    if (apertureDevName == NULL)
    {
	apertureDevName = "/dev/xsvc";
	if ((apertureDevFD_rw = open(apertureDevName, O_RDWR)) < 0)
	{
	    xf86MsgVerb(X_WARNING, 0,
			"solOpenAperture: failed to open %s (%s)\n",
			apertureDevName, strerror(errno));
	    apertureDevName = "/dev/fbs/aperture";
	    apertureDevFD_rw = open(apertureDevName, O_RDWR);
	}
	apertureDevFD_ro = open(apertureDevName, O_RDONLY);

	if ((apertureDevFD_rw < 0) || (apertureDevFD_ro < 0))
	{
	    xf86MsgVerb(X_WARNING, 0,
			"solOpenAperture: failed to open %s (%s)\n",
			apertureDevName, strerror(errno));
	    xf86MsgVerb(X_WARNING, 0,
			"solOpenAperture: either /dev/fbs/aperture"
			" or /dev/xsvc required\n");

	    apertureDevName = NULL;

	    if (apertureDevFD_rw >= 0)
	    {
		close(apertureDevFD_rw);
	    }
	    apertureDevFD_rw = -1;

	    if (apertureDevFD_ro >= 0)
	    {
		close(apertureDevFD_ro);
	    }
	    apertureDevFD_ro = -1;

	    return FALSE;
	}
    }
    return TRUE;
}

static pointer
solMapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int Flags)
{
    pointer base;
    int fd;
    int prot;

    if (Flags & VIDMEM_READONLY)
    {
	fd = apertureDevFD_ro;
	prot = PROT_READ;
    }
    else
    {
	fd = apertureDevFD_rw;
	prot = PROT_READ | PROT_WRITE;
    }

    if (fd < 0)
    {
	xf86DrvMsg(ScreenNum, X_ERROR,
		   "solMapVidMem: failed to open %s (%s)\n",
		   apertureDevName, strerror(errno));
	return NULL;
    }

    base = mmap(NULL, Size, prot, MAP_SHARED, fd, (off_t)Base);

    if (base == MAP_FAILED) {
        xf86DrvMsg(ScreenNum, X_ERROR,
		   "solMapVidMem: failed to mmap %s (0x%08lx,0x%lx) (%s)\n",
		   apertureDevName, Base, Size, strerror(errno));
	return NULL;
    }

    return base;
}

/* ARGSUSED */
static void
solUnMapVidMem(int ScreenNum, pointer Base, unsigned long Size)
{
    if (munmap(Base, Size) != 0) {
	xf86DrvMsgVerb(ScreenNum, X_WARNING, 0,
		       "solUnMapVidMem: failed to unmap %s"
		       " (0x%p,0x%lx) (%s)\n",
		       apertureDevName, Base, Size,
		       strerror(errno));
    }
}

_X_HIDDEN void
xf86OSInitVidMem(VidMemInfoPtr pVidMem)
{
    pVidMem->linearSupported = solOpenAperture();
    if (pVidMem->linearSupported) {
	pVidMem->mapMem = solMapVidMem;
	pVidMem->unmapMem = solUnMapVidMem;
    } else {
	xf86MsgVerb(X_WARNING, 0,
		    "xf86OSInitVidMem: linear memory access disabled\n");
    }
    pVidMem->initialised = TRUE;
}

/*
 * Read BIOS via mmap()ing physical memory.
 */
int
xf86ReadBIOS(unsigned long Base, unsigned long Offset, unsigned char *Buf,
	     int Len)
{
    unsigned char *ptr;
    int psize;
    int mlen;

    psize = getpagesize();
    Offset += Base & (psize - 1);
    Base &= ~(psize - 1);
    mlen = (Offset + Len + psize - 1) & ~(psize - 1);

    if (solOpenAperture() == FALSE)
    {
	xf86Msg(X_WARNING,
		"xf86ReadBIOS: Failed to open aperture to read BIOS\n");
	return -1;
    }

    ptr = (unsigned char *)mmap(NULL, mlen, PROT_READ,
				MAP_SHARED, apertureDevFD_ro, (off_t)Base);
    if (ptr == MAP_FAILED)
    {
	xf86Msg(X_WARNING, "xf86ReadBIOS: %s mmap failed [0x%08lx, 0x%04x]\n",
		apertureDevName, Base, mlen);
	return -1;
    }

    (void)memcpy(Buf, (void *)(ptr + Offset), Len);
    if (munmap((caddr_t)ptr, mlen) != 0) {
	xf86MsgVerb(X_WARNING, 0,
		    "xf86ReadBIOS: failed to unmap %s (0x%p,0x%x) (%s)\n",
		    apertureDevName, ptr, mlen, strerror(errno));
    }

    return Len;
}


/***************************************************************************/
/* I/O Permissions section						   */
/***************************************************************************/

#if defined(__i386__) || defined(__i386) || defined(__x86)
static Bool ExtendedEnabled = FALSE;
#endif

Bool
xf86EnableIO(void)
{
#if defined(__i386__) || defined(__i386) || defined(__x86)
    if (ExtendedEnabled)
	return TRUE;

    if (sysi86(SI86V86, V86SC_IOPL, PS_IOPL) < 0) {
	xf86Msg(X_WARNING, "xf86EnableIOPorts: Failed to set IOPL for I/O\n");
	return FALSE;
    }
    ExtendedEnabled = TRUE;
#endif /* i386 */
    return TRUE;
}

void
xf86DisableIO(void)
{
#if defined(__i386__) || defined(__i386) || defined(__x86)
    if(!ExtendedEnabled)
	return;

    sysi86(SI86V86, V86SC_IOPL, 0);

    ExtendedEnabled = FALSE;
#endif /* i386 */
}