/* $XFree86: xc/programs/Xserver/hw/xfree86/vbe/vbe.c,v 1.2tsi Exp $ */

/*

 *                   XFree86 vbe module

 *               Copyright 2000 Egbert Eich

 *

 * The mode query/save/set/restore functions from the vesa driver 

 * have been moved here.

 * Copyright (c) 2000 by Conectiva S.A. (http://www.conectiva.com)

 * Authors: Paulo César Pereira de Andrade <[email protected]> 

 */

#ifdef HAVE_XORG_CONFIG_H

#include <xorg-config.h>

#endif

#include "xf86.h"

#include "xf86_ansic.h"

#include "vbe.h"

#include <X11/Xarch.h>

#define DPMS_SERVER

#include <X11/extensions/dpms.h>

#define VERSION(x) VBE_VERSION_MAJOR(x),VBE_VERSION_MINOR(x)

#if X_BYTE_ORDER == X_LITTLE_ENDIAN

#define B_O16(x)  (x) 

#define B_O32(x)  (x)

#else

#define B_O16(x)  ((((x) & 0xff) << 8) | (((x) & 0xff) >> 8))

#define B_O32(x)  ((((x) & 0xff) << 24) | (((x) & 0xff00) << 8) \

                  | (((x) & 0xff0000) >> 8) | (((x) & 0xff000000) >> 24))

#endif

#define L_ADD(x)  (B_O32(x) & 0xffff) + ((B_O32(x) >> 12) & 0xffff00)

#define FARP(p)		(((unsigned)(p & 0xffff0000) >> 12) | (p & 0xffff))

#define R16(v)		((v) & 0xffff)

static unsigned char * vbeReadEDID(vbeInfoPtr pVbe);

static Bool vbeProbeDDC(vbeInfoPtr pVbe);

const char *vbe_ddcSymbols[] = {

    "xf86InterpretEDID",

    NULL

};

static const char vbeVersionString[] = "VBE2";

vbeInfoPtr

VBEInit(xf86Int10InfoPtr pInt, int entityIndex)

{

    return VBEExtendedInit(pInt, entityIndex, 0);

}

vbeInfoPtr

VBEExtendedInit(xf86Int10InfoPtr pInt, int entityIndex, int Flags)

{

    int RealOff;

    pointer page = NULL;

    ScrnInfoPtr pScrn = xf86FindScreenForEntity(entityIndex);

    vbeControllerInfoPtr vbe = NULL;

    Bool init_int10 = FALSE;

    vbeInfoPtr vip = NULL;

    int screen;

    if (!pScrn) return NULL;

    screen = pScrn->scrnIndex;

    if (!pInt) {

	if (!xf86LoadSubModule(pScrn, "int10"))

	    goto error;

	xf86DrvMsg(screen,X_INFO,"initializing int10\n");

	pInt = xf86ExtendedInitInt10(entityIndex,Flags);

	if (!pInt)

	    goto error;

	init_int10 = TRUE;

    }

    page = xf86Int10AllocPages(pInt,1,&RealOff);

    if (!page) goto error;

    vbe = (vbeControllerInfoPtr) page;    

    memcpy(vbe->VbeSignature,vbeVersionString,4);

    pInt->ax = 0x4F00;

    pInt->es = SEG_ADDR(RealOff);

    pInt->di = SEG_OFF(RealOff);

    pInt->num = 0x10;

    xf86ExecX86int10(pInt);

    if ((pInt->ax & 0xff) != 0x4f) {

	xf86DrvMsgVerb(screen,X_INFO,3,"VESA BIOS not detected\n");

	goto error;

    }

    switch (pInt->ax & 0xff00) {

    case 0:

	xf86DrvMsg(screen,X_INFO,"VESA BIOS detected\n");

	break;

    case 0x100:

	xf86DrvMsg(screen,X_INFO,"VESA BIOS function failed\n");

	goto error;

    case 0x200:

	xf86DrvMsg(screen,X_INFO,"VESA BIOS not supported\n");

	goto error;

    case 0x300:

	xf86DrvMsg(screen,X_INFO,"VESA BIOS not supported in current mode\n");

	goto error;

    default:

	xf86DrvMsg(screen,X_INFO,"Invalid\n");

	goto error;

    }

    xf86DrvMsgVerb(screen, X_INFO, 4,

		"VbeVersion is %d, OemStringPtr is 0x%08lx,\n"

		"\tOemVendorNamePtr is 0x%08lx, OemProductNamePtr is 0x%08lx,\n"

		"\tOemProductRevPtr is 0x%08lx\n",

		vbe->VbeVersion, (unsigned long)vbe->OemStringPtr,

		(unsigned long)vbe->OemVendorNamePtr,

		(unsigned long)vbe->OemProductNamePtr,

		(unsigned long)vbe->OemProductRevPtr);

    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE Version %i.%i\n",

		   VERSION(vbe->VbeVersion));

    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE Total Mem: %i kB\n",

		   vbe->TotalMem * 64);

    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM: %s\n",

		   (CARD8*)xf86int10Addr(pInt,L_ADD(vbe->OemStringPtr)));

    if (B_O16(vbe->VbeVersion) >= 0x200) {

	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM Software Rev: %i.%i\n",

		    VERSION(vbe->OemSoftwareRev));

	if (vbe->OemVendorNamePtr)

	    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM Vendor: %s\n",

		    (CARD8*)xf86int10Addr(pInt,L_ADD(vbe->OemVendorNamePtr)));

	if (vbe->OemProductNamePtr)

	    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM Product: %s\n",

		    (CARD8*)xf86int10Addr(pInt,L_ADD(vbe->OemProductNamePtr)));

	if (vbe->OemProductRevPtr)

	    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE OEM Product Rev: %s\n",

		    (CARD8*)xf86int10Addr(pInt,L_ADD(vbe->OemProductRevPtr)));

    }

    vip = (vbeInfoPtr)xnfalloc(sizeof(vbeInfoRec));

    vip->version = B_O16(vbe->VbeVersion);

    vip->pInt10 = pInt;

    vip->ddc = DDC_UNCHECKED;

    vip->memory = page;

    vip->real_mode_base = RealOff;

    vip->num_pages = 1;

    vip->init_int10 = init_int10;

    return vip;

 error:

    if (page)

	xf86Int10FreePages(pInt, page, 1);

    if (init_int10)

	xf86FreeInt10(pInt);

    return NULL;

}

void

vbeFree(vbeInfoPtr pVbe)

{

    if (!pVbe)

	return;

    xf86Int10FreePages(pVbe->pInt10,pVbe->memory,pVbe->num_pages);

    /* If we have initalized int10 we ought to free it, too */

    if (pVbe->init_int10) 

	xf86FreeInt10(pVbe->pInt10);

    xfree(pVbe);

    return;

}

static Bool

vbeProbeDDC(vbeInfoPtr pVbe)

{

    char *ddc_level;

    int screen = pVbe->pInt10->scrnIndex;

    if (!pVbe || (pVbe->ddc == DDC_NONE))

	return FALSE;

    if (pVbe->ddc != DDC_UNCHECKED)

	return TRUE;

    pVbe->pInt10->ax = 0x4F15;

    pVbe->pInt10->bx = 0;

    pVbe->pInt10->cx = 0;

    pVbe->pInt10->es = 0;

    pVbe->pInt10->di = 0;

    pVbe->pInt10->num = 0x10;

    xf86ExecX86int10(pVbe->pInt10);

    if ((pVbe->pInt10->ax & 0xff) != 0x4f) {

        xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC not supported\n");

	pVbe->ddc = DDC_NONE;

	return FALSE;

    }

    switch ((pVbe->pInt10->ax >> 8) & 0xff) {

    case 0:

	xf86DrvMsg(screen,X_INFO,"VESA VBE DDC supported\n");

	switch (pVbe->pInt10->bx & 0x3) {

	case 0:

  	    ddc_level = " none"; 

	    pVbe->ddc = DDC_NONE;

	    break;

	case 1:

  	    ddc_level = " 1";

	    pVbe->ddc = DDC_1;

	    break;

	case 2:

  	    ddc_level = " 2"; 

	    pVbe->ddc = DDC_2;

	    break;

	case 3:

  	    ddc_level = " 1 + 2"; 

	    pVbe->ddc = DDC_1_2;

	    break;

	default:

 	    ddc_level = "";

	    pVbe->ddc = DDC_NONE;

	    break;

	}

  	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC Level%s\n",ddc_level); 

  	if (pVbe->pInt10->bx & 0x4) {

    	    xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC Screen blanked" 

    			"for data transfer\n"); 

    	    pVbe->ddc_blank = TRUE;

    	}  else

    	    pVbe->ddc_blank = FALSE;

  	xf86DrvMsgVerb(screen,X_INFO,3,

		       "VESA VBE DDC transfer in appr. %x sec.\n", 

		       (pVbe->pInt10->bx >> 8) & 0xff); 

    }

    return TRUE; 

}

typedef enum {

  VBEOPT_NOVBE,

    VBEOPT_NODDC

} VBEOpts;

static const OptionInfoRec VBEOptions[] = {

    { VBEOPT_NOVBE,	"NoVBE",	OPTV_BOOLEAN,	{0},	FALSE },

    { VBEOPT_NODDC,	"NoDDC",	OPTV_BOOLEAN,	{0},	FALSE },

    { -1,		NULL,		OPTV_NONE,	{0},	FALSE },

};

static unsigned char *

vbeReadEDID(vbeInfoPtr pVbe)

{

    int RealOff = pVbe->real_mode_base;

    pointer page = pVbe->memory;

    unsigned char *tmp = NULL;

    Bool novbe = FALSE;

    Bool noddc = FALSE;

    int screen = pVbe->pInt10->scrnIndex;

    OptionInfoPtr options;

    if (!page) return NULL;

    options = xnfalloc(sizeof(VBEOptions));

    (void)memcpy(options, VBEOptions, sizeof(VBEOptions));

    xf86ProcessOptions(screen, xf86Screens[screen]->options, options);

    xf86GetOptValBool(options, VBEOPT_NOVBE, &novbe);

    xf86GetOptValBool(options, VBEOPT_NODDC, &noddc);

    xfree(options);

    if (novbe || noddc) return NULL;

    if (!vbeProbeDDC(pVbe)) goto error;

    memset(page,0,sizeof(vbeInfoPtr));

    strcpy(page,vbeVersionString);

    pVbe->pInt10->ax = 0x4F15;

    pVbe->pInt10->bx = 0x01;

    pVbe->pInt10->cx = 0;

    pVbe->pInt10->dx = 0;

    pVbe->pInt10->es = SEG_ADDR(RealOff);

    pVbe->pInt10->di = SEG_OFF(RealOff);

    pVbe->pInt10->num = 0x10;

    xf86ExecX86int10(pVbe->pInt10);

    if ((pVbe->pInt10->ax & 0xff) != 0x4f) {

        xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC invalid\n");

	goto error;

    }

    switch (pVbe->pInt10->ax & 0xff00) {

    case 0x0:

	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC read successfully\n");

  	tmp = (unsigned char *)xnfalloc(128); 

  	memcpy(tmp,page,128); 

	break;

    case 0x100:

	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC read failed\n");	

	break;

    default:

	xf86DrvMsgVerb(screen,X_INFO,3,"VESA VBE DDC unkown failure %i\n",

		       pVbe->pInt10->ax & 0xff00);

	break;

    }

 error:

    return tmp;

}

xf86MonPtr

vbeDoEDID(vbeInfoPtr pVbe, pointer pDDCModule)

{

    xf86MonPtr    pMonitor;

    pointer       pModule;

    unsigned char *DDC_data = NULL;

    ScrnInfoPtr   scrp;

    if (!pVbe) return NULL;

    if (pVbe->version < 0x200)

	return NULL;

    scrp = xf86Screens[pVbe->pInt10->scrnIndex];

    if (!(pModule = pDDCModule)) {

	pModule =

	    xf86LoadSubModule(scrp, "ddc");

	if (!pModule)

	    return NULL;

	xf86LoaderReqSymLists(vbe_ddcSymbols, NULL);

    }

    DDC_data = vbeReadEDID(pVbe);

    if (!DDC_data) 

	return NULL;

    pMonitor = xf86InterpretEDID(pVbe->pInt10->scrnIndex, DDC_data);

    if (pMonitor) {

	xf86DrvMsg(scrp->scrnIndex, X_PROBED,

	"VBE DDC detected a %s:\n", pMonitor->features.input_type ?

	"DFP" : "CRT");

	xf86PrintEDID(pMonitor);

	xf86DrvMsg(scrp->scrnIndex, X_INFO, "end of VBE DDC Monitor info\n");

    }

    if (!pDDCModule)

        xf86UnloadSubModule(pModule);

    return pMonitor;

}

#define GET_UNALIGNED2(x) \

            ((*(CARD16*)(x)) | (*(((CARD16*)(x) + 1))) << 16)

VbeInfoBlock *

VBEGetVBEInfo(vbeInfoPtr pVbe)

{

    VbeInfoBlock *block = NULL;

    int i, pStr, pModes;

    char *str;

    CARD16 major, *modes;

    bzero(pVbe->memory, sizeof(VbeInfoBlock));

    /*

    Input:

	AH    := 4Fh	Super VGA support

	AL    := 00h	Return Super VGA information

	ES:DI := Pointer to buffer

    Output:

	AX    := status

	(All other registers are preserved)

     */

    ((char*)pVbe->memory)[0] = 'V';

    ((char*)pVbe->memory)[1] = 'B';

    ((char*)pVbe->memory)[2] = 'E';

    ((char*)pVbe->memory)[3] = '2';

    pVbe->pInt10->num = 0x10;

    pVbe->pInt10->ax = 0x4f00;

    pVbe->pInt10->es = SEG_ADDR(pVbe->real_mode_base);

    pVbe->pInt10->di = SEG_OFF(pVbe->real_mode_base);

    xf86ExecX86int10(pVbe->pInt10);

    if (R16(pVbe->pInt10->ax) != 0x4f)

	return (NULL);

    block = xcalloc(sizeof(VbeInfoBlock), 1);

    block->VESASignature[0] = ((char*)pVbe->memory)[0];

    block->VESASignature[1] = ((char*)pVbe->memory)[1];

    block->VESASignature[2] = ((char*)pVbe->memory)[2];

    block->VESASignature[3] = ((char*)pVbe->memory)[3];

    block->VESAVersion = *(CARD16*)(((char*)pVbe->memory) + 4);

    major = (unsigned)block->VESAVersion >> 8;

    pStr = GET_UNALIGNED2((((char*)pVbe->memory) + 6));

    str = xf86int10Addr(pVbe->pInt10, FARP(pStr));

    block->OEMStringPtr = strdup(str);

    block->Capabilities[0] = ((char*)pVbe->memory)[10];

    block->Capabilities[1] = ((char*)pVbe->memory)[11];

    block->Capabilities[2] = ((char*)pVbe->memory)[12];

    block->Capabilities[3] = ((char*)pVbe->memory)[13];

    pModes = GET_UNALIGNED2((((char*)pVbe->memory) + 14));

    modes = xf86int10Addr(pVbe->pInt10, FARP(pModes));

    i = 0;

    while (modes[i] != 0xffff)

	i++;

    block->VideoModePtr = xalloc(sizeof(CARD16) * i + 1);

    memcpy(block->VideoModePtr, modes, sizeof(CARD16) * i);

    block->VideoModePtr[i] = 0xffff;

    block->TotalMemory = *(CARD16*)(((char*)pVbe->memory) + 18);

    if (major < 2)

	memcpy(&block->OemSoftwareRev, ((char*)pVbe->memory) + 20, 236);

    else {

	block->OemSoftwareRev = *(CARD16*)(((char*)pVbe->memory) + 20);

	pStr = GET_UNALIGNED2((((char*)pVbe->memory) + 22));

	str = xf86int10Addr(pVbe->pInt10, FARP(pStr));

	block->OemVendorNamePtr = strdup(str);

	pStr = GET_UNALIGNED2((((char*)pVbe->memory) + 26));

	str = xf86int10Addr(pVbe->pInt10, FARP(pStr));

	block->OemProductNamePtr = strdup(str);

	pStr = GET_UNALIGNED2((((char*)pVbe->memory) + 30));

	str = xf86int10Addr(pVbe->pInt10, FARP(pStr));

	block->OemProductRevPtr = strdup(str);

	memcpy(&block->Reserved, ((char*)pVbe->memory) + 34, 222);

	memcpy(&block->OemData, ((char*)pVbe->memory) + 256, 256);

    }

    return (block);

}

void

VBEFreeVBEInfo(VbeInfoBlock *block)

{

    xfree(block->OEMStringPtr);

    xfree(block->VideoModePtr);

    if (((unsigned)block->VESAVersion >> 8) >= 2) {

	xfree(block->OemVendorNamePtr);

	xfree(block->OemProductNamePtr);

	xfree(block->OemProductRevPtr);

    }

    xfree(block);

}

Bool

VBESetVBEMode(vbeInfoPtr pVbe, int mode, VbeCRTCInfoBlock *block)

{

    /*

    Input:

	AH    := 4Fh	Super VGA support

	AL    := 02h	Set Super VGA video mode

	BX    := Video mode

	    D0-D8  := Mode number

	    D9-D10 := Reserved (must be 0)

	    D11    := 0 Use current default refresh rate

		   := 1 Use user specified CRTC values for refresh rate

	    D12-13	Reserved for VBE/AF (must be 0)

	    D14    := 0 Use windowed frame buffer model

		   := 1 Use linear/flat frame buffer model

	    D15    := 0 Clear video memory

		   := 1 Don't clear video memory

	ES:DI := Pointer to VbeCRTCInfoBlock structure

    Output: AX = Status

	(All other registers are preserved)

    */

    pVbe->pInt10->num = 0x10;

    pVbe->pInt10->ax = 0x4f02;

    pVbe->pInt10->bx = mode;

    if (block) {

	pVbe->pInt10->bx |= 1 << 11;

	memcpy(pVbe->memory, block, sizeof(VbeCRTCInfoBlock));

	pVbe->pInt10->es = SEG_ADDR(pVbe->real_mode_base);

	pVbe->pInt10->di = SEG_OFF(pVbe->real_mode_base);

    } else

	pVbe->pInt10->bx &= ~(1 << 11);

    xf86ExecX86int10(pVbe->pInt10);

    return (R16(pVbe->pInt10->ax) == 0x4f);

}

Bool

VBEGetVBEMode(vbeInfoPtr pVbe, int *mode)

{

    /*

    Input:

	AH := 4Fh	Super VGA support

	AL := 03h	Return current video mode

    Output:

	AX := Status

	BX := Current video mode

	(All other registers are preserved)

    */

    pVbe->pInt10->num = 0x10;

    pVbe->pInt10->ax = 0x4f03;

    xf86ExecX86int10(pVbe->pInt10);

    if (R16(pVbe->pInt10->ax) == 0x4f) {

	*mode = R16(pVbe->pInt10->bx);

	return (TRUE);

    }

    return (FALSE);

}

VbeModeInfoBlock *

VBEGetModeInfo(vbeInfoPtr pVbe, int mode)

{

    VbeModeInfoBlock *block = NULL;

    bzero(pVbe->memory, sizeof(VbeModeInfoBlock));

    /*