/*

 * Copyright (c) 2008, 2009, 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.

 */

/*

 * Copyright 2000 through 2004 by Marc Aurele La France (TSI @ UQV), [email protected]

 *

 * 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 name of Marc Aurele La France not be used in advertising or

 * publicity pertaining to distribution of the software without specific,

 * written prior permission.  Marc Aurele La France makes no representations

 * about the suitability of this software for any purpose.  It is provided

 * "as-is" without express or implied warranty.

 *

 * MARC AURELE LA FRANCE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO

 * EVENT SHALL MARC AURELE LA FRANCE 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.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <string.h>

#include <stdio.h>

#include "radeon.h"

#include "radeon_probe.h"

#include "radeon_version.h"

#include "xf86.h"

#include "xf86_OSproc.h"

#include "efb.h"

#include "fb.h"

#ifdef XSERVER_LIBPCIACCESS

#include "pciaccess.h"

#endif

/* Module loader interface for subsidiary driver module */

static XF86ModuleVersionInfo EFBVersionRec =

{

    RADEON_DRIVER_NAME,

    MODULEVENDORSTRING,

    MODINFOSTRING1,

    MODINFOSTRING2,

    XORG_VERSION_CURRENT,

    RADEON_VERSION_MAJOR, RADEON_VERSION_MINOR, RADEON_VERSION_PATCH,

    ABI_CLASS_VIDEODRV,

    ABI_VIDEODRV_VERSION,

    MOD_CLASS_VIDEODRV,

    {0, 0, 0, 0}

};

/*

 * EFBSetup --

 *

 * This function is called every time the module is loaded.

 */

static pointer

EFBSetup

(

    pointer Module,

    pointer Options,

    int     *ErrorMajor,

    int     *ErrorMinor

)

{

    static Bool Inited = FALSE;

    if (!Inited) {

        Inited = TRUE;

        xf86AddDriver(&RADEON, Module, HaveDriverFuncs);

    }

    return (pointer)TRUE;

}

/* The following record must be called efbModuleData */

_X_EXPORT XF86ModuleData efbModuleData =

{

    &EFBVersionRec,

    EFBSetup,

    NULL

};

#define EFB_REG_SIZE       256*1024

#define EFB_REG_SIZE_LOG2  18

#ifndef XSERVER_LIBPCIACCESS

pciVideoPtr EFBGetPciInfo(RADEONInfoPtr info)

{

    int status;

    pciVideoPtr pciInfo = NULL;

    int i;

    int cmd = GFX_IOCTL_GET_PCI_CONFIG;

    struct gfx_pci_cfg  pciCfg;

    int bar;

    if ((status = ioctl(info->fd, GFX_IOCTL_GET_PCI_CONFIG, &pciCfg))

		!= -1) {

        pciInfo = malloc(sizeof(pciVideoRec));

	pciInfo->vendor = pciCfg.VendorID;

	pciInfo->chipType = pciCfg.DeviceID;

	pciInfo->chipRev = pciCfg.RevisionID;

	pciInfo->subsysVendor = pciCfg.SubVendorID;

	pciInfo->subsysCard = pciCfg.SubSystemID;

	// TODO: need to fill in the complete structure

	//

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

	    bar = pciCfg.bar[i];

	    if (bar != 0) {

		if (bar & PCI_MAP_IO) {

		    pciInfo->ioBase[i] = (memType)PCIGETIO(bar);

		    pciInfo->type[i] = bar & PCI_MAP_IO_ATTR_MASK;

		    // TODO: size?

		} else {

		    pciInfo->type[i] = bar & PCI_MAP_MEMORY_ATTR_MASK;

		    pciInfo->memBase[i] = (memType)PCIGETMEMORY(bar);

		    if (PCI_MAP_IS64BITMEM(bar)) {

                        if (i == 5) {

                            pciInfo->memBase[i] = 0;

                        } else {

                            int  bar_hi = pciCfg.bar[i+1];

                            /* 64 bit architecture */

                            pciInfo->memBase[i] |=

                                        (memType)bar_hi << 32;

                            ++i;    /* Step over the next BAR */

                        }

		    }

		    pciInfo->size[i] = EFB_REG_SIZE_LOG2;

		}

	    }

	}

    }

    return pciInfo;

}

#else

/*

 * These defines are from the xorg 1.3 xf86pci.h

 */

#define PCI_MAP_MEMORY                  0x00000000

#define PCI_MAP_IO                      0x00000001

#define PCI_MAP_MEMORY_TYPE             0x00000007

#define PCI_MAP_MEMORY_TYPE_64BIT       0x00000004

#define PCI_MAP_IO_TYPE                 0x00000003

#define PCI_MAP_MEMORY_ADDRESS_MASK     0xfffffff0

#define PCI_MAP_IO_ADDRESS_MASK         0xfffffffc

#define PCI_MAP_IS_IO(b)        ((b) & PCI_MAP_IO)

#define PCI_MAP_IS64BITMEM(b)   \

        (((b) & PCI_MAP_MEMORY_TYPE) == PCI_MAP_MEMORY_TYPE_64BIT)

#define PCIGETMEMORY(b)         ((b) & PCI_MAP_MEMORY_ADDRESS_MASK)

#define PCIGETMEMORY64HIGH(b)   (*((CARD32*)&(b) + 1))

#define PCIGETMEMORY64(b)       \

        (PCIGETMEMORY(b) | ((CARD64)PCIGETMEMORY64HIGH(b) << 32))

#define PCIGETIO(b)             ((b) & PCI_MAP_IO_ADDRESS_MASK)

struct pci_device * EFBGetPciInfo(RADEONInfoPtr info)

{

    int status;

    struct pci_device *pciInfo = NULL;

    int i;

    int cmd = GFX_IOCTL_GET_PCI_CONFIG;

    struct gfx_pci_cfg  pciCfg;

    int bar;

    if ((status = ioctl(info->fd, GFX_IOCTL_GET_PCI_CONFIG, &pciCfg))

		!= -1) {

        pciInfo = malloc(sizeof(struct pci_device));

	pciInfo->vendor_id = pciCfg.VendorID;

	pciInfo->device_id = pciCfg.DeviceID;

	pciInfo->revision = pciCfg.RevisionID;

	pciInfo->subvendor_id = pciCfg.SubVendorID;

	pciInfo->subvendor_id = pciCfg.SubSystemID;

	// TODO: need to fill in the complete structure

	//

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

	    bar = pciCfg.bar[i];

	    if (bar != 0) {

		if (PCI_MAP_IS_IO(bar)) {

		    pciInfo->regions[i].base_addr = (pciaddr_t)PCIGETIO(bar);

		} else {

		    pciInfo->regions[i].size = EFB_REG_SIZE;

		    if (PCI_MAP_IS64BITMEM(bar)) {

		        pciInfo->regions[i].base_addr = (pciaddr_t)PCIGETMEMORY64(bar);

                        ++i;    /* Step over the next BAR */

		    } else {

		        pciInfo->regions[i].base_addr = (pciaddr_t)PCIGETMEMORY(bar);

		    }

		}

	    }

	}

    }

    return pciInfo;

}

#endif

pointer

EFBMapVidMem(ScrnInfoPtr pScrn, unsigned int flags, PCITAG picTag, 

			unsigned long base, unsigned long size)

{

    int BUS_BASE = 0;

    pointer memBase;

    int fdd;

    int mapflags = MAP_SHARED;

    int prot;

    memType realBase, alignOff;

    unsigned long realSize;

    int pageSize;

    RADEONInfoPtr  info = RADEONPTR(pScrn);

    fdd = info->fd;

    realBase = base & ~(getpagesize() - 1);

    alignOff = base - realBase;

    pageSize = getpagesize();

    realSize = size + (pageSize - 1) & (~(pageSize - 1));

    printf("base: %lx, realBase: %lx, alignOff: %lx \n",

                base, realBase, alignOff);

    if (flags & VIDMEM_READONLY) {

        prot = PROT_READ;

    } else {

        prot = PROT_READ | PROT_WRITE;

    }

    memBase = mmap((caddr_t)0, realSize + alignOff, prot, mapflags, fdd,

                (off_t)(off_t)realBase + BUS_BASE);

    if (memBase == MAP_FAILED) {

        printf("RADEONMapVidMem: Could not map framebuffer\n");

        return NULL;

    }

    return ((char *)memBase + alignOff);

}

void

EFBUnmapVidMem(ScrnInfoPtr pScrn, pointer base, unsigned long size)

{

    memType alignOff = (memType)base - ((memType)base & ~(getpagesize() - 1));

    printf("alignment offset: %lx\n",alignOff);

    munmap((caddr_t)((memType)base - alignOff), (size + alignOff));

    return;

}

void

EFBNotifyModeChanged(ScrnInfoPtr pScrn)

{

    RADEONInfoPtr  info = RADEONPTR(pScrn);

    int status;

    struct gfx_video_mode mode;

    if (pScrn->currentMode->name) {

	strlcpy(mode.mode_name, pScrn->currentMode->name, GFX_MAX_VMODE_LEN);

    } else {

	strlcpy(mode.mode_name, " ", GFX_MAX_VMODE_LEN);

    }

    mode.vRefresh = pScrn->currentMode->VRefresh;

    status = ioctl(info->fd, GFX_IOCTL_SET_VIDEO_MODE, &mode);

}

void

EFBScreenInit(ScrnInfoPtr pScrn)

{

    RADEONInfoPtr  info = RADEONPTR(pScrn);

    if (xf86ReturnOptValBool(info->Options, OPTION_DISABLE_RANDR, FALSE)) {

   	xf86DrvMsg (pScrn->scrnIndex, X_INFO, "RANDR is disabled\n");

        //

        // disable RANDR

        // 

        EnableDisableExtension("RANDR", FALSE);

    }

    EFBNotifyModeChanged(pScrn);

}

void

EFBCloseScreen(ScrnInfoPtr pScrn)

{

    EFBNotifyModeChanged(pScrn);

}

DisplayModePtr

EFBOutputGetEDIDModes(xf86OutputPtr output)

{

    xf86MonPtr  edid_mon = output->MonInfo;

    if (!strcmp(edid_mon->vendor.name, "SUN")) {

	if (edid_mon->ver.version == 1 &&

		edid_mon->ver.revision <= 2) {

	    //

	    // force detail timing to be the preferred one

	    //

	    edid_mon->features.msc |= 0x2;

	}

    }

    return (xf86OutputGetEDIDModes(output));

}

DisplayModePtr

efb_get_modes(xf86OutputPtr output)

{

    ScrnInfoPtr pScrn = output->scrn;

    DisplayModePtr pModes;

    pModes = RADEONProbeOutputModes(output);

    //

    // display modes have precedence

    //

    if (pScrn->display->modes[0] != NULL) {

        int mm;

        char *modes;

        DisplayModePtr dModes, preferredMode = NULL;

        int found = 0, done = 0;

        for (mm = 0; pScrn->display->modes[mm] != NULL && !found; mm++) {

            modes = pScrn->display->modes[mm];

            if (!strcasecmp(modes, "Auto") || !strcasecmp(modes, "None")) {

		done = found = 1;

            } else {

                done = 0;

                dModes = pModes;

                while (dModes && !done) {

                    if (!strcmp(modes, dModes->name)) {

                        done = found = 1;

			dModes->type |= M_T_PREFERRED;

			preferredMode = dModes;

                    } else {

                        dModes = dModes->next;

                    }

                }

            }

        }

        if (found && preferredMode) {

	    dModes = pModes;

	    while (dModes) {

		if ((dModes->type & M_T_PREFERRED) &&

		        (dModes != preferredMode)) {

		    dModes->type &= ~M_T_PREFERRED;

		}

		dModes = dModes->next;

	    }

	}

    }

    return(pModes);

}

char *efb_default_mode = "1024x768";

float ratio[] = { 10/16,	/* 16:10 AR */

		  3/4,		/*  4:3  AR */

		  4/5,		/*  5:4  AR */

		  9/16		/* 16:9  AR */

		};

char *efb_get_edid_preferred_mode(ScrnInfoPtr pScrn, int head)

{

    RADEONInfoPtr      info = RADEONPTR(pScrn);

    int                i, status;

    unsigned int       length;

    gfx_edid_t         edid_buf;

    unsigned char      *data;

    unsigned char      *mode = "1280x1024";

    unsigned char      pmode[10];

    unsigned char      *vblk, *pblk;

    unsigned int       width = 0, height = 0;

    edid_buf.head = head;

    edid_buf.version = GFX_EDID_VERSION;

    status = ioctl(info->fd, GFX_IOCTL_GET_EDID_LENGTH, &edid_buf);

    if (status == -1) {

	return strdup(efb_default_mode);

    }

    data = edid_buf.data = (char *)malloc(edid_buf.length);

    status = ioctl(info->fd, GFX_IOCTL_GET_EDID, &edid_buf);

    if (status == -1) {

	return strdup(efb_default_mode);

    }

    vblk = data + 8 + 10; 			/* skip header & product info */

    pblk = vblk + 2 + 5 + 10 + 3 + 16;	/* skip to preferred timing block */

    for (i = 0; i < 4 && width == 0; i++, pblk+=18) {

	if (!((pblk[0] == 0) && (pblk[0] == 0))) {

            width = pblk[2] | ((pblk[4] & 0xf0) << 4);

            height = pblk[5] | ((pblk[7] & 0xf0) << 4);

	}

    }

    sprintf(pmode, "%dx%d", width, height);

    return strdup(pmode);

}

void efb_set_position(xf86CrtcConfigPtr config, BOOL swap, 

			int pos1X, int pos1Y, int pos2X, int pos2Y)

{

    int o;

    xf86OutputPtr output;

    char *value[2];

    char str[20];

    OptionInfoRec *p;

    int first = 0;

    int second = 1;

    if (swap) {

	first = 1;

	second = 0;

    }

    sprintf(str,"%d %d", pos1X, pos1Y);

    value[first] = strdup(str);

    sprintf(str,"%d %d", pos2X, pos2Y);

    value[second] = strdup(str);

    for (o = 0; o < 2; o++) {

        output = config->output[o];

	for (p = output->options; p->token >= 0; p++) {

	    if (strcmp(p->name, "Position") == 0) {

		if (!p->found) {

		    p->value.str = value[o];

		    p->found = TRUE;

		}

	    }

	} 

    }

}

void EFBPreInitOutputConfiguration(ScrnInfoPtr pScrn, xf86CrtcConfigPtr config)

{

    RADEONInfoPtr      info = RADEONPTR(pScrn);

    Bool doubleWide = FALSE;

    Bool doubleHigh = FALSE;

    Bool swap = FALSE;

    int  offset = 0, position = 0;

    int  head0 = GFX_EDID_HEAD_ONE;

    int  head1 = GFX_EDID_HEAD_TWO;

    char *str;

    str = xf86GetOptValString(info->Options, OPTION_DUAL_DISPLAY);

    if ((str != NULL) && (strcasecmp(str, "Enable") == 0)) {

	doubleWide = TRUE;

    }

    str = xf86GetOptValString(info->Options, OPTION_DUAL_DISPLAY_VERTICAL);

    if ((str != NULL) && (strcasecmp(str, "Enable") == 0)) {

	doubleHigh = TRUE;

    }

    // do the output configuration here only if dual display is enabled

    if ((doubleWide == FALSE) && (doubleHigh == FALSE)) {

	return;

    }

    if ((doubleWide == TRUE) || (doubleHigh == TRUE)) {

	char *outputOrder;

        outputOrder = xf86GetOptValString(info->Options, OPTION_OUTPUTS);

        if ((outputOrder != NULL) && (strcasecmp(outputOrder, "Swapped") == 0)) {

	    swap = TRUE;

	    head0 = GFX_EDID_HEAD_TWO;

            head1 = GFX_EDID_HEAD_ONE;

        }