dalmm.c

此代码为WCE5.0下显示器的源代码

        {
          ulReturn = CWDDEMM_ERR_BADOUTPUTSIZE;
        }
        else
        {
          lpMMAsicId = (MM_ASICID FAR *)lpOutput;
          lpMMAsicId->ulSize  = sizeof(MM_ASICID);
          lpMMAsicId->ulAsicId = lpHDE->hwAsicID.ulChipID;
        }          
    }
    *lpInfoSize = sizeof(MM_ASICID);
    break;
    
    case CWDDEMM_GetHardwareConfigTable:
    {
        UCHAR             aucTempBuffer[256];
        LPUCHAR           lpucByte;
        ULONG             ulBytesReturned;
        MM_HDWCONFIG FAR  * lpMMHDWCONFIG;
        ULONG             i;
        LPDEVGCO          lpController = NULL;


        if (ulInputSize < sizeof(CWDDEMMCMD))
        {
          // input size is less than expected
          ulReturn = CWDDEMM_ERR_BADINPUTSIZE;
        }
        else
        {          
          // search for a controller owned by this driver
          for (i = 0; i < lpHDE->ulControllersCount; i++)
          {
            if (lpHDE->aControllerMap[lpMmCmd->ulDriverReserved] & VECTORFROMINDEX(i))
            {
              lpController = (LPDEVGCO) &lpHDE->aControllers[i];
              break;
            }
          }

          if (lpController)
          {
            // we found a controller
            if (lpController->lpHWED->ulFunctionHooks & GCO_HOOK_GET_HARDWARE_INFO_TABLE)
            {
              if ((*lpController->lpHWED->pfnGetHardwareInfoTable)(lpController->hGCO, (LPUCHAR)aucTempBuffer,
                                                  (LPULONG) &ulBytesReturned))
              {
                lpMMHDWCONFIG = (MM_HDWCONFIG FAR *)lpOutput;

                if (ulOutputSize < sizeof(MM_HDWCONFIG))
                {
                  ulReturn = CWDDEMM_ERR_BADOUTPUTSIZE;
                }
                else
                {
                  lpMMHDWCONFIG = (MM_HDWCONFIG FAR *)lpOutput;

                  lpucByte = (LPUCHAR)lpOutput + sizeof(MM_HDWCONFIG);

                  for (i = 0; (i < (ulOutputSize - sizeof(MM_HDWCONFIG))) && (i < ulBytesReturned); i++)
                  {
                    *(lpucByte + i) = aucTempBuffer[i];
                  }
                  
                  lpMMHDWCONFIG->ulSize = ulOutputSize;
                  lpMMHDWCONFIG->ulBytesReturned = ulBytesReturned;
                }
              }
              else
              {
                ulReturn = CWDDEMM_ERR_NOTAVAILABLE;
              }
            }
            else
            {
              ulReturn = CWDDEMM_ERR_NOTAVAILABLE;
            }
          }
          else
          {
            ulReturn = CWDDEMM_ERR_BADINPUT;
          }
        }
    }
    *lpInfoSize = ulOutputSize;
    break;

    case CWDDEMM_GetMultimediaConfigTable:   
    {
        UCHAR                   aucTempBuffer[256];
        ULONG                   ulBytesReturned;
        LPUCHAR                 lpucByte;
        MM_MULTIMEDIATABLE FAR  *lpMMMultiMediaTable;
        ULONG                   i;
        LPDEVGCO                lpController = NULL;

        if (ulInputSize < sizeof(CWDDEMMCMD))
        {
          // input size is less than expected
          ulReturn = CWDDEMM_ERR_BADINPUTSIZE;
        }
        else
        {          
          // search for a controller owned by this driver
          for (i = 0; i < lpHDE->ulControllersCount; i++)
          {
            if (lpHDE->aControllerMap[lpMmCmd->ulDriverReserved] & VECTORFROMINDEX(i))
            {
              lpController = (LPDEVGCO) &lpHDE->aControllers[i];
              break;
            }
          }

          if (lpController)
          {
            // we found a controller
            if (lpController->lpHWED->ulFunctionHooks & GCO_HOOK_GET_MULTIMEDIA_TABLE)
            {
              if ((*lpController->lpHWED->pfnGetMultimediaTable)(lpController->hGCO, (LPUCHAR)aucTempBuffer,
                                                  (LPULONG) &ulBytesReturned))
              {
                if (ulOutputSize < sizeof(MM_MULTIMEDIATABLE))
                {
                  ulReturn = CWDDEMM_ERR_BADOUTPUTSIZE;
                }
                else
                {
                  lpMMMultiMediaTable = (MM_MULTIMEDIATABLE FAR  *)lpOutput;

                  lpucByte = (LPUCHAR)lpOutput + sizeof(MM_MULTIMEDIATABLE);

                  for (i = 0; (i < (ulOutputSize - sizeof(MM_MULTIMEDIATABLE))) && 
                                   (i < ulBytesReturned); i++)
                  {
                    *(lpucByte + i) = aucTempBuffer[i];
                  }
                  
                  lpMMMultiMediaTable->ulSize = ulOutputSize;
                  lpMMMultiMediaTable->ulBytesReturned = ulBytesReturned;      
                }
              }
              else
              {
                ulReturn = CWDDEMM_ERR_NOTAVAILABLE;
              }
            }
            else
            {
              ulReturn = CWDDEMM_ERR_NOTAVAILABLE;
            }
          }
          else
          {
            ulReturn = CWDDEMM_ERR_BADINPUT;
          }
        }
    }
    *lpInfoSize = ulOutputSize;
    break;
    case CWDDEMM_Test_GetCRC:   
    {
      MM_ULONG              FAR *lpMMUlong;
      MM_TESTCRCINPUT       FAR *lpMMTestCRCInput;
      ULONG                 ulGetCRCFlag = 0;
      LPDEVGCO              lpController = NULL;
      
      if (ulInputSize < (sizeof(CWDDEMMCMD)+ sizeof(MM_TESTCRCINPUT)))
	  ulReturn = CWDDEMM_ERR_BADINPUTSIZE;
      else if (ulOutputSize < sizeof(MM_ULONG))
	  ulReturn = CWDDEMM_ERR_BADOUTPUTSIZE;
      else if (lpMmCmd->ulHandle >= lpHDE->ulControllersCount) //here use ulHandle as controllerIndex (0 based).
       ulReturn = CWDDEMM_ERR_BADINPUT;
      else if ((!(lpHDE->aControllerMap[lpMmCmd->ulDriverReserved]
		 &VECTORFROMINDEX(lpMmCmd->ulHandle)))
		 &&(lpHDE->aControllers[lpMmCmd->ulHandle].ulFlags & GCO_MAPPED))
      {
         // calling driver does not own the controller, so fail the call
         ulReturn = CWDDEMM_ERR_BADINPUT;
      }  
      else
      {
        lpMMTestCRCInput   = (MM_TESTCRCINPUT FAR*) (lpMmCmd + 1);
        lpMMUlong          = (MM_ULONG FAR *) lpOutput;
        lpMMUlong->ulSize  = sizeof(MM_ULONG);
        lpMMUlong->ulValue = 0; 
        if(lpMMTestCRCInput->ulGetCRCFlag&(TESTCRC_ENABLE_CRC|TESTCRC_READ_CRC))
        {
	    if(lpMMTestCRCInput->ulGetCRCFlag&TESTCRC_ENABLE_CRC)
           {ulGetCRCFlag |= CRC_ENABLE;}
          if(lpMMTestCRCInput->ulGetCRCFlag&TESTCRC_READ_CRC)
           {ulGetCRCFlag |= CRC_READ;}
          lpController = (LPDEVGCO) &lpHDE->aControllers[lpMmCmd->ulHandle];
       
    	    if(lpController->lpHWED->ulFunctionHooks & GCO_HOOK_GETCRC)
		lpMMUlong->ulValue = (*lpController->lpHWED->pfnGetCRC)
		(lpController->hGCO, lpMmCmd->ulHandle, ulGetCRCFlag);	
    	    else
 	      ulReturn = CWDDEMM_ERR_UNSUPPORTED;
        }
        else 
	   ulReturn = CWDDEMM_ERR_BADINPUT;
     }
    }
    *lpInfoSize = ulOutputSize;
    break;
   
    case CWDDEMM_Test_GetBandwidthData:   
    {
      LPDEVGCO                lpController = NULL;
     // ULONG                   i, ulCount;
      if (ulInputSize < sizeof(CWDDEMMCMD))
        ulReturn = CWDDEMM_ERR_BADINPUTSIZE;
      else if (lpMmCmd->ulHandle >= lpHDE->ulControllersCount) //here use ulHandle as controllerIndex (0 based).
        ulReturn = CWDDEMM_ERR_BADINPUT;
      else if (ulOutputSize < sizeof(MM_BANDWIDTHDATA))
        ulReturn = (ULONG)CWDDEMM_ERR_BADOUTPUTSIZE;
      else if ((!(lpHDE->aControllerMap[lpMmCmd->ulDriverReserved]
              &VECTORFROMINDEX(lpMmCmd->ulHandle))) &&
             (lpHDE->aControllers[lpMmCmd->ulHandle].ulFlags & GCO_MAPPED))
        ulReturn = CWDDEMM_ERR_BADINPUT;
     else
     {
        MM_BANDWIDTHDATA FAR * lpMm_BandwidthData;
        lpMm_BandwidthData = (MM_BANDWIDTHDATA FAR *) (lpOutput);

        lpController = (LPDEVGCO) &lpHDE->aControllers[lpMmCmd->ulHandle];
        if ((lpController!= NULL)&& (lpController->ulDisplays)&&(lpMm_BandwidthData!=NULL )) 
        {
          //Get Mode_Info from EnabledData .
          MOVEMEMORY((LPDEVMODE_INFO)&(lpMm_BandwidthData->dmInfo),
                   (LPDEVMODE_INFO)&(lpController->sModeInfo), sizeof(DEVMODE_INFO));
		
          lpMm_BandwidthData->ulDisplayType = lpController->ulDisplayTypes;
	
          //Get AvailableBandwidth based on current mode.
          MOVEMEMORY((LPVOID) &(lpMm_BandwidthData->aAvailableBandwidth),
	            (LPVOID)&(lpController->lpHWED->sAvailBandwidth), sizeof(FIXEDPOINT));
          
          if (lpController->lpHWED->ulFunctionHooks &  GCO_CALCULATE_HORIZONTAL_TIME )
          {
            //Get AvailableHTimeTotal based on current mode
            (*lpController->lpHWED->pfnGetTotalHTime)(lpController->hGCO, 
                 (LPHORIZONTAL_TIME)&(lpMm_BandwidthData->sAvailableHTime),
                 (LPDEVMODE_INFO)&(lpController->sModeInfo), (ULONG)lpController->ulDisplayTypes);
            
           //Get Requested HTime based on Current mode. 
            (*lpController->lpHWED->pfnCalculateModeHorizontalTime)(lpController->hGCO,
                 &lpController->sModeInfo, (LPHORIZONTAL_TIME)&(lpMm_BandwidthData->sRequestedModeHTime));         
          }

          //Get Requested Memory Bandwidth for the current mode.
          if (lpController->lpHWED->ulFunctionHooks & GCO_CALCULATE_MEMORY_BANDWIDTH)
          {
            if (lpController->lpHWED->ulFunctionHooks2 & GCO_HOOK2_CALCULATE_MODE_BANDWIDTH_EX)
            {
              DAL_CRTC_TIMING sTiming;
              ZEROMEMORY(&sTiming, sizeof(DAL_CRTC_TIMING));

              (*lpController->lpHWED->pfnGCOGetDetailedTiming)(lpController->hGCO,
                                                          lpController->ulController,
                                                          NULL, //To get current mode timing
                                                          &sTiming);   
          
      
              (*lpController->lpHWED->pfnCalculateModeBandwidthEx) (lpController->hGCO, 
                  &lpController->sModeInfo,  (LPDAL_CRTC_TIMING)&sTiming, &lpMm_BandwidthData->sRequestedModeBandwidth);        
            }
            else
            {
              (*lpController->lpHWED->pfnCalculateModeBandwidth)(lpController->hGCO, 
                   &lpController->sModeInfo, (LPFIXEDPOINT)&(lpMm_BandwidthData->sRequestedModeBandwidth));
            }
          }
         		
        }
        else 
          ulReturn = CWDDEMM_ERR_BADINPUT;
      }
				
    }
	*lpInfoSize = ulOutputSize;
    break;
    case CWDDEMM_Test_GetHardwareData:
    {
      MM_ULONG       FAR* lpMMUlong;
      MM_HARDWAREDATAINPUT FAR* lpMM_HardwareDataInput;
      GCO_HW_REGISTER sGco_Hw_Register;
      LPDEVGCO  lpController = NULL;

      ZEROMEMORY((LPVOID)&sGco_Hw_Register, sizeof(GCO_HW_REGISTER));

      if (ulInputSize < (sizeof(CWDDEMMCMD)+ sizeof(MM_HARDWAREDATAINPUT)))
        ulReturn = CWDDEMM_ERR_BADINPUTSIZE;
      else if (lpMmCmd->ulHandle >= lpHDE->ulControllersCount)
        //here use ulHandle as controllerIndex (0 based).
        ulReturn = (ULONG) CWDDEMM_ERR_BADINPUT;
      else if (ulOutputSize < sizeof(MM_ULONG))
        ulReturn = (ULONG)CWDDEMM_ERR_BADOUTPUTSIZE;
      else if ((!(lpHDE->aControllerMap[lpMmCmd->ulDriverReserved] &
                         VECTORFROMINDEX(lpMmCmd->ulHandle))) &&
                         (lpHDE->aControllers[lpMmCmd->ulHandle].ulFlags & GCO_MAPPED))
      {// calling driver does not own the controller, so fail the call
        ulReturn = CWDDEMM_ERR_BADINPUT;
      }  
      else
      {
        lpMM_HardwareDataInput = (MM_HARDWAREDATAINPUT FAR*) (lpMmCmd + 1);
        lpMMUlong  = (MM_ULONG FAR *) lpOutput;
        lpMMUlong->ulSize  = sizeof(MM_ULONG);
        lpMMUlong->ulValue = 0; 
        lpController = (LPDEVGCO) &lpHDE->aControllers[lpMmCmd->ulHandle];
     	
        if(lpController->lpHWED->ulFunctionHooks &  GCO_HOOK_GETHWDATA)
        {
          sGco_Hw_Register.ulIndexDataOffset = lpMM_HardwareDataInput->ulIndexDataOffset;
          sGco_Hw_Register.ulIndexValue = lpMM_HardwareDataInput->ulIndexValue;
          sGco_Hw_Register.ulIndexValueShiftLeft = lpMM_HardwareDataInput->ulIndexValueShiftLeft;
          sGco_Hw_Register.ulRegOffset = lpMM_HardwareDataInput->ulRegOffset;
          sGco_Hw_Register.ulRegOffsetIndexMask = lpMM_HardwareDataInput->ulRegOffsetIndexMask;
         
          lpMMUlong->ulValue = (*lpController->lpHWED->pfnGetHardwareData)
                              (lpController->hGCO, lpMM_HardwareDataInput->ulOptionFlag, 
                              lpMmCmd->ulHandle,(LPGCO_HW_REGISTER)(&sGco_Hw_Register)) ;
        }
        else
          ulReturn = CWDDE_ERR_UNSUPPORTED;
      }
    }
    *lpInfoSize = ulOutputSize;
    break;

    case CWDDEMM_ValidateOverlayTheaterMode:
    {
      ulReturn = ulValidateOverlayTheaterMode(lpHDE, lpInput);
    }
    *lpInfoSize = 0;
    break;

    case CWDDEMM_SetOverlayTheaterMode:
    {
      ulReturn = ulSetOverlayTheaterMode(lpHDE, lpInput);
    }
    *lpInfoSize = 0;
    break;

    case CWDDEMM_ResetOverlayTheaterMode:
    {
      ulReturn = ulResetOverlayTheaterMode(lpHDE, lpInput);
    }
    *lpInfoSize = 0;
    break;

  default:
    ulReturn = CWDDE_ERR_UNSUPPORTED;
    break;
  }

DALCWDDEMM_Return:

  DALDEBUG((DALDBG_ENTRY_EXIT, "DALCWDDEMM - Exit"));
  return(ulReturn);

}