lpAdapterPowerCaps->sPowerState[i].ulFlags |= CWDDEDI_POWERSTATE_FLAGS_MEMORYSHARESCORECLK;
            }
            else if (lpHDE->sAdapterPowerStates.sGCOPowerState[i].ulFlags & DAL_GCOPOWERSTATE_FLAGS_CORESHARESMEMORYCLK)
            {
              lpAdapterPowerCaps->sPowerState[i].ulFlags |= CWDDEDI_POWERSTATE_FLAGS_CORESHARESMEMORYCLK;
            }

            if (lpHDE->sAdapterPowerStates.sGCOPowerState[i].ulFlags & DAL_GCOPOWERSTATE_FLAGS_LOWVOLTAGE)
            {
              lpAdapterPowerCaps->sPowerState[i].ulFlags |= CWDDEDI_POWERSTATE_FLAGS_LOWVOLTAGE;
            }

            if (lpHDE->sAdapterPowerStates.sGCOPowerState[i].ulFlags & DAL_GCOPOWERSTATE_FLAGS_LOWPANELREFRESHRATE)
            {
              lpAdapterPowerCaps->sPowerState[i].ulFlags |= CWDDEDI_POWERSTATE_FLAGS_LOWPANELREFRESHRATE;
              lpAdapterPowerCaps->sPowerState[i].ulRefreshRate = lpHDE->sAdapterPowerStates.sGCOPowerState[i].ulRefreshRate;
            }

            lpAdapterPowerCaps->sPowerState[i].ulMemoryClock = lpHDE->sAdapterPowerStates.sGCOPowerState[i].ulMemoryClock;
            lpAdapterPowerCaps->sPowerState[i].ulCoreClock   = lpHDE->sAdapterPowerStates.sGCOPowerState[i].ulCoreClock;
          }
        }
        else
        {
          ulReturn = CWDDE_ERR_UNSUPPORTED;
        }
      }

      *lpInfoSize = sizeof(DI_ADAPTERPOWERCAPS);
      break;
    }

    case CWDDEDI_AdapterGetPowerState:
    {

      if (ulOutputSize < sizeof(DI_POWERSETTING))
      {
        // cannot return the version because there is insufficient room in
        // the output buffer
        ulReturn = CWDDE_ERR_BADOUTPUTSIZE;
      }
      else
      {
        if (lpHDE->bPowerPlaySupported)
        {
          DI_POWERSETTING FAR * lpPowerSetting = (DI_POWERSETTING FAR *)lpOutput;
          ZEROMEMORY(lpPowerSetting, sizeof(DI_POWERSETTING));
          lpPowerSetting->ulSize   = sizeof(DI_POWERSETTING);
        
          lpPowerSetting->ulRequestedPowerState = lpHDE->ulRequestedPowerState;
          lpPowerSetting->ulCurrentPowerState = lpHDE->ulCurrentPowerState; 
        }
        else
        {
          ulReturn = CWDDE_ERR_UNSUPPORTED;
        }
      }

      *lpInfoSize = sizeof(DI_POWERSETTING);
      break;
    }

    case CWDDEDI_AdapterSetPowerState:
    {
      if (ulInputSize < (sizeof(CWDDECMD) + sizeof(DI_POWERSETTING)))
      {
        // input size of the buffer is less than the command buffer
        ulReturn = CWDDE_ERR_BADINPUTSIZE;
      } 
      else
      {

        DI_POWERSETTING FAR * lpPowerSetting = (DI_POWERSETTING FAR *)(lpCmd + 1);

        ulReturn = DALCWDDE_AdapterSetPowerState(lpHDE,
                                                 lpCmd->ulDriverReserved,
                                                 TRUE,
                                                 lpPowerSetting);
      }

      *lpInfoSize = 0;
      break;
    }

    case CWDDEDI_AdapterGetPowerStateOptions:
    {

      if (ulOutputSize < sizeof(DI_POWERSTATEOPTIONS))
      {
        // cannot return the version because there is insufficient room in
        // the output buffer
        ulReturn = CWDDE_ERR_BADOUTPUTSIZE;
      }
      else
      {
                
        if (lpHDE->bPowerPlaySupported)
        {
          DI_POWERSTATEOPTIONS FAR * lpPowerStateoptions = (DI_POWERSTATEOPTIONS FAR *)lpOutput;          
          ZEROMEMORY(lpPowerStateoptions, sizeof(DI_POWERSTATEOPTIONS));
          lpPowerStateoptions->ulSize   = sizeof(DI_POWERSTATEOPTIONS);

          // return options if the power play feature is supported.
          if (lpHDE->ulPowerStateOptions & DAL_PWRSTATEOPTION_POWERPLAYFEATUREENABLE)
          {
            lpPowerStateoptions->ulFeature = (ULONG)CWDDEDI_ADAPTER_PWROPTIONS_FEATURE_ENABLE;
          }
          else
          {
            lpPowerStateoptions->ulFeature = (ULONG)CWDDEDI_ADAPTER_PWROPTIONS_FEATURE_DISABLE;
          }

          if (lpHDE->ulPowerStateOptions & DAL_PWRSTATEOPTION_LOWERTO16BPP)
          {
            lpPowerStateoptions->ulOptions |= CWDDEDI_ADAPTER_PWROPTIONS_LOWERTO16BPP_OPTION; 
          }
          else
          {
            lpPowerStateoptions->ulOptions &= ~CWDDEDI_ADAPTER_PWROPTIONS_LOWERTO16BPP_OPTION; 
          }
        }
        else
        {
          ulReturn = CWDDE_ERR_UNSUPPORTED;
        }
      }


      *lpInfoSize = sizeof(DI_POWERSTATEOPTIONS);
      break;
    }

    case CWDDEDI_AdapterSetPowerStateOptions:
    {

      if (ulInputSize < (sizeof(CWDDECMD) + sizeof(DI_POWERSTATEOPTIONS)))
      {
        // input size of the buffer is less than the command buffer
        ulReturn = CWDDE_ERR_BADINPUTSIZE;
      } 
      else
      {        
        if (lpHDE->bPowerPlaySupported)
        {
          DI_POWERSETTING sPowerSetting;
          DI_POWERSTATEOPTIONS FAR * lpPowerStateoptions = (DI_POWERSTATEOPTIONS FAR *)(lpCmd + 1);

          ZEROMEMORY((DI_POWERSETTING FAR *)&sPowerSetting, sizeof(DI_POWERSETTING));

          lpHDE->ulPowerStateOptions = 0;

          if (lpPowerStateoptions->ulFeature)
          {
            lpHDE->ulPowerStateOptions |= DAL_PWRSTATEOPTION_POWERPLAYFEATUREENABLE;
          }

          if (lpPowerStateoptions->ulOptions & CWDDEDI_ADAPTER_PWROPTIONS_LOWERTO16BPP_OPTION)
          {
            lpHDE->ulPowerStateOptions |= DAL_PWRSTATEOPTION_LOWERTO16BPP;
          }

          sPowerSetting.ulSize   = sizeof(DI_POWERSETTING);
          sPowerSetting.ulRequestedPowerState = lpHDE->ulRequestedPowerState;

          DALCWDDE_AdapterSetPowerState(lpHDE,
                                        lpCmd->ulDriverReserved,
                                        FALSE,
                                        (DI_POWERSETTING FAR *)&sPowerSetting);
          
          lpHDE->ulFlags |= HDAL_SAVEPOWERPLAYOPTION;
        }
        else
        {
          ulReturn = CWDDE_ERR_UNSUPPORTED;
        }
      }

      *lpInfoSize = 0;
      break;
    }
    case CWDDEDI_AdapterGetClockInfo:
    {
      
      DI_ADAPTERCLOCK_INFO FAR *lpAdapterClkInfo;
      if (ulOutputSize < sizeof(DI_ADAPTERCLOCK_INFO))
      {
        ulReturn = CWDDE_ERR_BADOUTPUTSIZE;
      }
      else
      {
        LPDEVGCO lpController;
        DAL_ADAPTERCLOCK_INFO  sDalAdapterClkInfo;
        ZEROMEMORY(&sDalAdapterClkInfo, sizeof(DAL_ADAPTERCLOCK_INFO));
        sDalAdapterClkInfo.ulSize = sizeof(DAL_ADAPTERCLOCK_INFO);
      
        lpAdapterClkInfo = (DI_ADAPTERCLOCK_INFO FAR *) lpOutput;
        lpController = &lpHDE->aControllers[DAL_PRIMARY_CONTROLLER];
    
        // Get CLK info from Primary GCO.
        if (lpController->lpHWED->ulFunctionHooks2 & GCO_HOOK2_GETCLKINFO)
        {
          (*lpController->lpHWED->pfnGetClockInfo)(
                                lpController->hGCO, (LPDAL_ADAPTERCLOCK_INFO) &sDalAdapterClkInfo);
          
          lpAdapterClkInfo ->ulFlag = 0; 
          //translate DAL to DI 
          if(sDalAdapterClkInfo.ulFlag & DAL_GCOCLOCKINFO_FLAGS_MEMORYSHARESCORECLK)
          {
            lpAdapterClkInfo ->ulFlag |= CWDDEDI_GCOCLOCKINFO_FLAGS_MEMORYSHARESCORECLK;
          }
          if(sDalAdapterClkInfo.ulFlag & DAL_GCOCLOCKINFO_FLAGS_CORESHARESMEMORYCLK)
          {
            lpAdapterClkInfo ->ulFlag |=  CWDDEDI_GCOCLOCKINFO_FLAGS_CORESHARESMEMORYCLK;
          }
          lpAdapterClkInfo ->sMemoryClk.ulDefaultClk = sDalAdapterClkInfo.sMemoryClk.ulDefaultClk;
          lpAdapterClkInfo ->sMemoryClk.ulCurrentClk = sDalAdapterClkInfo.sMemoryClk.ulCurrentClk;
          lpAdapterClkInfo ->sMemoryClk.ulMaxSetClk  = sDalAdapterClkInfo.sMemoryClk.ulMaxSetClk;
          lpAdapterClkInfo ->sMemoryClk.ulMinSetClk  = sDalAdapterClkInfo.sMemoryClk.ulMinSetClk;

          lpAdapterClkInfo ->sCoreClk.ulDefaultClk = sDalAdapterClkInfo.sCoreClk.ulDefaultClk;
          lpAdapterClkInfo ->sCoreClk.ulCurrentClk = sDalAdapterClkInfo.sCoreClk.ulCurrentClk;
          lpAdapterClkInfo ->sCoreClk.ulMaxSetClk  = sDalAdapterClkInfo.sCoreClk.ulMaxSetClk;
          lpAdapterClkInfo ->sCoreClk.ulMinSetClk  = sDalAdapterClkInfo.sCoreClk.ulMinSetClk;
         
          ulReturn = CWDDE_OK;
 
        }
        else
        {
          ulReturn = CWDDE_ERR_UNSUPPORTED;
        }
      }
      *lpInfoSize = sizeof(DI_ADAPTERCLOCK_INFO);
      break;
    }

    case CWDDEDI_AdapterSetClockConfig:
    {
      
      if (ulInputSize < sizeof(CWDDECMD) + sizeof(DI_ADAPTERCLOCK_CONFIG))
      {
        ulReturn = CWDDE_ERR_BADINPUTSIZE;

      }
      else
      {
        DI_ADAPTERCLOCK_CONFIG FAR *lpDiAdapterClkCfg;
        
        lpDiAdapterClkCfg= (DI_ADAPTERCLOCK_CONFIG FAR *) (lpCmd + 1);
        
        ulReturn = DALCWDDE_AdapterSetClockConfig(lpHDE,
                                                  lpDiAdapterClkCfg);                                       
                                                        
      }
      *lpInfoSize = 0;
      break;
    }

    case CWDDEDI_AdapterGetOverlayInfo:
    {
      if (ulOutputSize < sizeof(DIOVERLAYINFO))
      {
        ulReturn = CWDDE_ERR_BADOUTPUTSIZE;
      }
      else
      {
        ulReturn = ulCWDDEDI_GetOverlayInfo(lpHDE, lpCmd->ulDriverReserved, lpOutput);
      }

      *lpInfoSize = sizeof(DIOVERLAYINFO);
      break;
    }

 
    case CWDDEDI_AdapterTestHarness:
    {
      if (ulInputSize < (sizeof(CWDDECMD) + sizeof(MESSAGECODEINFO)))
      {
        // input size of the buffer is less than the command buffer
        ulReturn = CWDDE_ERR_BADINPUTSIZE;
      } 
      else
      {
        MESSAGECODEINFO FAR * lpMessageCodeInfo = (MESSAGECODEINFO FAR *)(lpCmd + 1);
        BOOL bRet = DDLMessageCode(lpHDE->hDDL, lpCmd->ulDriverReserved, lpMessageCodeInfo->ulMessageCode, 
                                   lpMessageCodeInfo->ulBufferSize, (LPVOID)lpMessageCodeInfo->aBuf);
        if(bRet)
        {
          ulReturn = CWDDE_OK;
        }
        else
        {
          ulReturn = CWDDE_ERR_FUNCTION_FAILED;
        }
      }

      break;
    }


   case CWDDEDI_ControllerGetCaps:
      {
        CONTROLLERCAPS FAR *lpControllerCaps;
        LPDEVGCO            lpController;
        ULONG               ulCaps;

        if (lpCmd->ulIndex >= lpHDE->ulControllersCount)
        {
          ulReturn = CWDDE_ERR_BADINPUT;
        } else if (ulOutputSize < sizeof(CONTROLLERCAPS))
        {
          // cannot return the version because there is insufficient room in
          // the output buffer for an CONTROLLERCAPS structure

          ulReturn = CWDDE_ERR_BADOUTPUTSIZE;
        } else
        {
          lpController = (LPDEVGCO) &lpHDE->aControllers[lpCmd->ulIndex];

          lpControllerCaps = (CONTROLLERCAPS FAR *)lpOutput;
          lpControllerCaps->ulSize = sizeof(CONTROLLERCAPS);

          ulCaps = lpController->lpHWED->aControllerCaps[lpCmd->ulIndex];
          lpControllerCaps->ulCapsSupported = 0;
          i = 1;
          j = 0;

          while(ulCaps >> j++)
          {
            switch( ulCaps & i )
            {
              case DAL_CONTROLLER_CAPS_EXPANSION:
                lpControllerCaps->ulCapsSupported |= CWDDEDI_CONTROLLER_CAPS_EXPANSION;
                break;

              case DAL_CONTROLLER_CAPS_OVERLAY:
                lpControllerCaps->ulCapsSupported |= CWDDEDI_CONTROLLER_CAPS_OVERLAY;
                break;

              case DAL_CONTROLLER_CAPS_VGA:
                lpControllerCaps->ulCapsSupported |= CWDDEDI_CONTROLLER_CAPS_VGA;
                break;

              case DAL_CONTROLLER_CAPS_HW_CURSOR:
                lpControllerCaps->ulCapsSupported |= CWDDEDI_CONTROLLER_CAPS_HW_CURSOR;
                break;