//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
/****************************************************************************\
*
*  Module Name    dalcwdde.c
*  Project        ATI Display Abstraction Layer
*  Device         RageProPNP / Rage128 (Win95/98 & WinNT 4.0/5.0)
*
*  Description    source file for Display Abstraction Layer 0.87
*                 contains functions for processing CWDDE Extensions
*
*  Copyright (c) 1998-2002 ATI Technologies Inc. (unpublished)
*
*  All rights reserved.  This notice is intended as a precaution against
*  inadvertent publication and does not imply publication or any waiver
*  of confidentiality.  The year included in the foregoing notice is the
*  year of creation of the work.
*
*  Refer to DAL Developers Guide & Programming Reference Rev 0.87 for usage
*
\****************************************************************************/

#include "dal.h"
#include "daldef.h"
#include "dalddc.h"
#include "cwddedi.h"
#include "cwddemm.h"
#include "cwddeth.h"
#include "atimcode.h"

typedef CWDDECMD FAR *LPCWDDECMD;

const DAL_GDOGCO_ADJUSTMENT aGCO_Adjustment[] = 
  {//*********** ulHook ***************************Hookindex**
   { GCO_HOOK_TEXT_CURSOR_BLINKING_ADJUSTMENT       , 0 },
   { GCO_HOOK_RATIOMETRIC_EXPANSION_ADJUSTMENT      , 0 },
   { GCO_HOOK_OVERLAY_CHROMACITY_ADJUSTMENT         , 0 },
   { GCO_HOOK_OVERLAY_BLACKWHITELEVEL_ADJUSTMENT    , 0 }
};


//
// DALCWDDE.C - functions are declared locally only since no other files in
//              DAL include the CWDDE header files
//


ULONG DALCWDDE_AdapterSetPowerState(LPHW_DAL_EXTENSION   lpHDE,
                                    ULONG                ulDriverID,
                                    BOOL                 bNewRequest,
                                    DI_POWERSETTING FAR *lpPowerSetting);

ULONG DALCWDDE_ControllerValidateConfig(LPHW_DAL_EXTENSION lpHDE,
                                        ULONG ulDriverID,
                                        LPCWDDECMD lpCmd,
                                        CONTROLLERCONFIG FAR *lpControllerConfig,
                                        ULONG ulConfigCount);

ULONG DALCWDDE_ControllerSetConfig(LPHW_DAL_EXTENSION lpHDE,
                                   ULONG ulDriverID,
                                   LPCWDDECMD lpCmd,
                                   CONTROLLERCONFIG FAR *lpControllerConfig,
                                   ULONG ulConfigCount);

ULONG DALCWDDE_ControllerEnumNextView(LPHW_DAL_EXTENSION lpHDE,
                                      LPDAL_MODEINFO FAR *lplpDalMode,
                                      CONTROLLERVIEW FAR *lpControllerView,
                                      ULONG ulController, ULONG ulDisplays);

ULONG DALCWDDE_ControllerEnumNextRefresh(LPHW_DAL_EXTENSION lpHDE,
                                         LPDAL_MODEINFO FAR *lplpDalMode,
                                         CONTROLLERENUMREFRESH FAR * lpEnumRefresh,
                                         ULONG FAR *lpRefresh, ULONG ulController);


ULONG DALCWDDE_DisplayGetCaps(LPHW_DAL_EXTENSION lpHDE, LPDEVGDO lpDisplay);
ULONG DALCWDDE_DisplayGetInfo(LPHW_DAL_EXTENSION lpHDE, LPCWDDECMD lpCmd,
                  LPVOID lpOutput);

ULONG DALCWDDE_DisplayGetConfig(LPHW_DAL_EXTENSION lpHDE, LPCWDDECMD lpCmd,
                LPVOID lpOutput);

ULONG DALCWDDE_DisplaySetConfig(LPHW_DAL_EXTENSION lpHDE, LPCWDDECMD lpCmd,
                LPVOID lpInput);

ULONG DALCWDDE_AdapterFlushData(LPHW_DAL_EXTENSION lpHDE, ULONG ulDriverID,
                                SAVEDATA FAR *lpSaveData);

ULONG DALCWDDE_DisplaySetLimits(LPHW_DAL_EXTENSION lpHDE,LPCWDDECMD lpCmd,
                                DISPLAYLIMITS FAR *lpDisplaySetLimits);


ULONG DALCWDDE_DisplayGetDDCInfo(LPHW_DAL_EXTENSION lpHDE, LPCWDDECMD lpCmd,
                                 LPVOID lpOutput);


ULONG DALCWDDE_MM(HDAL hDAL, LPVOID lpInput, ULONG ulInputSize, LPVOID lpOutput,
                  ULONG ulOutputSize, LPLONG lpInfoSize);


ULONG DALCWDDE_DisplaySetRefreshRate(LPHW_DAL_EXTENSION lpHDE, LPCWDDECMD lpCmd, DISPLAYREFRESHRATE FAR *lpDisplayRefreshRate );

ULONG DALCWDDE_DisplayGetRefreshRate(LPHW_DAL_EXTENSION lpHDE, LPCWDDECMD lpCmd, LPVOID lpOutput);

ULONG DALCWDDE_DisplayGetRefreshRateCaps(LPHW_DAL_EXTENSION lpHDE, LPCWDDECMD lpCmd, LPVOID lpOutput);

static ULONG ulGetAdapterDefaultSetting(
  LPHW_DAL_EXTENSION  lpHDE,
  ULONG               ulDriverIndex,
  ULONG               ulOutputSize,
  ADAPTERSETTING FAR* lpAdapterSetting);

static ULONG 
ulGetDisplayAdjustmentIndex(
  ULONG              ulAdjustType);

static ULONG 
ulGetDisplayAdjustmentInfo(
  LPHW_DAL_EXTENSION lpHDE, 
  LPDEVGDO           lpDisplay, 
  ULONG              ulAdjustType, 
  LPHW_ADJUSTMENT    lpAdjustment);

static ULONG 
ulGetDisplayAdjustmentData(
  LPHW_DAL_EXTENSION lpHDE, 
  LPDEVGDO           lpDisplay, 
  ULONG              ulAdjustType, 
  LPLONG             lpData);

static ULONG 
ulSetDisplayAdjustmentData(
  LPHW_DAL_EXTENSION lpHDE, 
  LPDEVGDO           lpDisplay, 
  ULONG              ulAdjustType, 
  LONG               lData);

static ULONG ulGetAdapterConfig(
  LPHW_DAL_EXTENSION  lpHDE,
  ULONG               ulConfig,
  LPULONG             lpulValue);

static ULONG ulSetAdapterConfig(
  LPHW_DAL_EXTENSION  lpHDE,
  ULONG               ulConfig,
  ULONG               ulValue);

static ULONG DALCWDDE_DisplayGetEDIDData(
  LPHW_DAL_EXTENSION        lpHDE,
  CWDDECMD             FAR *lpCmd,
  DISPLAYEDIDDATAINPUT FAR *lpOption,
  DISPLAYEDIDDATA      FAR *lpEDIDData);

static ULONG DALCWDDE_AdapterSetClockConfig(
  LPHW_DAL_EXTENSION lpHDE,
  DI_ADAPTERCLOCK_CONFIG FAR *lpDiAdapterClkCfg);

/******************************Public*Routine******************************\
*
* BOOL DALCWDDE()
*
* Processes the Common Windows Display Driver Extensions (Display Interface)
* function calls, with adapter, controller, or display escape calls.
*
* Note:
*
\**************************************************************************/

ULONG DALCWDDE(
HDAL hDAL,
LPVOID lpInput,
ULONG ulInputSize,
LPVOID lpOutput,
ULONG ulOutputSize,
LPLONG lpInfoSize)
{
  LPHW_DAL_EXTENSION  lpHDE;
  LPCWDDECMD          lpCmd;
  ULONG               ulReturn;
  ULONG               i, j;

  DALDEBUG((DALDBG_ENTRY_EXIT, "DALCWDDE - Entry"));
  DALASSERT((hDAL != NULL), "DAL handle 'hDAL' is NULL!");

  // grab the structure for the DAL out of the DDL's handle to it
  lpHDE = (LPHW_DAL_EXTENSION)hDAL;
  ulReturn = (ULONG)CWDDE_OK;

  if (ulInputSize < sizeof(CWDDECMD))
  {
    // size of the input structure is smaller than the size of the CWDDE
    // command block and hence the DAL cannot process the call.

    ulReturn = (ULONG)CWDDE_ERR_BADINPUTSIZE;
    goto DALCWDDE_Return;
  }

  lpCmd = (LPCWDDECMD)lpInput;

  if (lpCmd->ulDriverReserved >= MAX_NUMBER_CONTROLLERS)
  {
    // caller provided an invalid value for the DriverID in the reserved
    // field of the CWDDE command block, hence fail the call.

    ulReturn = (ULONG)CWDDE_ERR_BADINPUT;
    goto DALCWDDE_Return;
  }

  switch(lpCmd->ulEscape32)
  {
    case CWDDEDI_AdapterGetVersion:
      {
        OUTPUTULONG FAR *lpOutputUlong;

        // used to return the version of the CWDDE API Extensions API support
        // which is CWDDEDI_VERSION from the CWDDE header file.

        if (ulOutputSize < sizeof(OUTPUTULONG))
        {
          // cannot return the version because there is insufficient room in
          // the output buffer for a OUTPUTULONG.

          ulReturn = CWDDE_ERR_BADOUTPUTSIZE;
        } else
        {
          // Return version number as defined in cwddedi.h:
          // the version should always come directly from the header file and
          // not be hardcoded by the developer!

          lpOutputUlong          = (OUTPUTULONG FAR *) lpOutput;
          lpOutputUlong->ulSize  = sizeof(OUTPUTULONG);
          lpOutputUlong->ulValue = CWDDEDI_VERSION;
        }
      }
      *lpInfoSize = sizeof(OUTPUTULONG);
      break;

    case CWDDEDI_AdapterGetCaps:

      // returns the capabilities of the adapter, hence the capabilities of
      // the one or more controllers.

      {
        ADAPTERCAPS FAR *lpAdapterCaps;
        LPDEVGCO         lpController;

        if (ulOutputSize < sizeof(ADAPTERCAPS))
        {
          // cannot return the version because there is insufficient room in
          // the output buffer for an ADAPTERCAPS structure

          ulReturn = CWDDE_ERR_BADOUTPUTSIZE;
        } else
        {
          lpAdapterCaps = (ADAPTERCAPS FAR *) lpOutput;
          lpAdapterCaps->ulSize = sizeof(ADAPTERCAPS);
          lpAdapterCaps->ulAdapterID = (ULONG) *((LPULONG) &hDAL);    // EPR 35062
          lpAdapterCaps->ulNumControllers = lpHDE->ulControllersCount;
          lpAdapterCaps->ulNumDisplays = lpHDE->ulDisplaysCount;

          // poll each controller to see if it supports overlay.
          lpAdapterCaps->ulNumOverlays = 0;
          for (i = 0; i < lpHDE->ulControllersCount; i++)
          {
            lpController = (LPDEVGCO) &lpHDE->aControllers[i];
            if (lpController->lpHWED->aControllerCaps[i] & DAL_CONTROLLER_CAPS_OVERLAY)
              lpAdapterCaps->ulNumOverlays += 1;
          }

          lpAdapterCaps->ulCaps = 0;
          if (  (GCO_HOOK2_VALIDATEMODE & lpHDE->aControllers[0].lpHWED->ulFunctionHooks2)
              &&(lpHDE->aControllers[0].lpHWED->pfnValidateMode                          ))
          {
            lpAdapterCaps->ulCaps |= CWDDEDI_ADAPTER_CAPS_SUPPORTREGISTRYDETAILEDTIMING;

            if (lpHDE->ulControllersCount > 1)
            {
              lpAdapterCaps->ulCaps |= CWDDEDI_ADAPTER_CAPS_SUPPORTLARGEDESKTOP;
            }
          }

          // force these values to zero in case the caller is trying to read
          // so information out of these in a future version and we do not
          // support that future version.
          lpAdapterCaps->ulReserved2 = 0;
          lpAdapterCaps->ulReserved3 = 0;
        }
      }
      *lpInfoSize = sizeof(ADAPTERCAPS);
      break;

    case CWDDEDI_AdapterGetInfo:

      // returns information about the adapter ... at present, only the
      // connected displays are required.

      {
        ADAPTERINFO FAR *lpAdapterInfo;

        if (ulOutputSize < sizeof(ADAPTERINFO))
        {
          // cannot return the version because there is insufficient room in
          // the output buffer for an ADAPTERCAPS structure

          ulReturn = CWDDE_ERR_BADOUTPUTSIZE;
        } else
        {
          lpAdapterInfo = (ADAPTERINFO FAR *) lpOutput;
          lpAdapterInfo->ulSize = sizeof(ADAPTERINFO);

          if (lpHDE->ulDalRule1 & DALRULE1_DISABLECWDDEDETECTION)
          {
            // Since the INF suggests not to do the detection return
            // from dal stored data. Warning : This flag will limit
            // device detection to boot time only.
            lpAdapterInfo->ulDisplaysHaveLoad = lpHDE->ulConnectedDisplays;
          }
          else
          {
            if (lpHDE->ulFlags & HDAL_INITIALIZING)
            {
             lpAdapterInfo->ulDisplaysHaveLoad = lpHDE->ulConnectedDisplays;
            }
            else
            {           
              lpAdapterInfo->ulDisplaysHaveLoad = ulDetectConnectedDisplays(lpHDE);

              // Save the current detected displays in DAL. This is needed
              // when saving object map on a detection scheme.
              lpHDE->ulConnectedDisplays = lpAdapterInfo->ulDisplaysHaveLoad;

        			// Update connected displays in BIOS Scratch Registers
              // Do not update CMOS
              vUpdateBIOSDisplayInfo(lpHDE, TRUE, FALSE);
            }
          }

          lpAdapterInfo->ulHotPluggableDisplays = lpHDE->ulHotPlaggableDisplays;