bkldrvapi.cpp

PXA270平台下WINCE6.0的背光控制驱动

    {
        RETAILMSG(1, (L"ERROR: BKL_IoControl: "
            L"User mode calls not allowed.\r\n"));
        SetLastError(ERROR_ACCESS_DENIED);

	return FALSE;
    }

    // Verify context
    if(! dwOpenContext)
    {
        RETAILMSG(ZONE_ERROR, (L"ERROR: BKL_IoControl: "
            L"Incorrect context paramer\r\n" ));

        return FALSE;
    }

    pBKLinfo = (BKL_MDD_INFO *) dwOpenContext;

    switch (dwIoControlCode) 
    {
        case IOCTL_POWER_CAPABILITIES:  
            DEBUGMSG(ZONE_BACKLIGHT, (TEXT("BKL: IOCTL_POWER_CAPABILITIES\r\n")));
            if (lpOutBuf && nOutBufSize >= sizeof (POWER_CAPABILITIES) && lpBytesReturned) 
            {
                __try 
                {
                    PPOWER_CAPABILITIES PowerCaps = (PPOWER_CAPABILITIES)lpOutBuf;

                    memset(PowerCaps, 0, sizeof(*PowerCaps));
                    PowerCaps->DeviceDx = BacklightGetSupportedStates();
                    *lpBytesReturned = sizeof(*PowerCaps);

                    pBKLinfo->ucSupportedStatesMask = PowerCaps->DeviceDx;

                    ASSERT(pBKLinfo->ucSupportedStatesMask < 0x20);
                    
                    dwErr = ERROR_SUCCESS;
                }
                __except(EXCEPTION_EXECUTE_HANDLER) 
                {
                    DEBUGMSG(ZONE_BACKLIGHT, (TEXT("exception in ioctl\r\n")));
                }
            }

            break;

        case IOCTL_POWER_QUERY: // determines whether changing power state is feasible
                DEBUGMSG(ZONE_BACKLIGHT,(TEXT("BKL: Received IOCTL_POWER_QUERY\r\n")));
                if (lpOutBuf && nOutBufSize >= sizeof(CEDEVICE_POWER_STATE)) 
                {
                    // Return a good status on any valid query, since we are always ready to
                    // change power states (if asked for state we don't support, we move to next highest, eg D3->D4).
                    __try 
                    {
                        CEDEVICE_POWER_STATE ReqDx = *(PCEDEVICE_POWER_STATE)lpOutBuf;

                        if (VALID_DX(ReqDx)) 
                        {
                            // This is a valid Dx state so return a good status.
                            dwErr = ERROR_SUCCESS;
                        }

                        DEBUGMSG(ZONE_BACKLIGHT, (TEXT("BKL: IOCTL_POWER_QUERY %s\r\n"), dwErr == ERROR_SUCCESS ? (TEXT("succeeded")) : (TEXT("failed")) ));
                    }
                    __except(EXCEPTION_EXECUTE_HANDLER) 
                    {
                        DEBUGMSG(ZONE_BACKLIGHT, (TEXT("Exception in ioctl\r\n")));
                    }
                }
                break;

            break;

        case IOCTL_POWER_SET: // requests a change from one device power state to another
                DEBUGMSG(ZONE_BACKLIGHT,(TEXT("BKL: Received IOCTL_POWER_SET\r\n")));
                if (lpOutBuf && nOutBufSize >= sizeof(CEDEVICE_POWER_STATE)) 
                {
                    __try 
                    {
                        CEDEVICE_POWER_STATE ReqDx = *(PCEDEVICE_POWER_STATE)lpOutBuf;

                        DEBUGMSG(ZONE_BACKLIGHT, (TEXT("IOCTL_POWER_SET request to D%u \r\n"), ReqDx));
                        if (VALID_DX(ReqDx)) 
                        {
                            CEDEVICE_POWER_STATE SupportedDx = ReqDx;
                            
                            // figure out which state to ask driver to go to:
                            if(GetBestSupportedState(pBKLinfo, ReqDx, &SupportedDx))
                            {       
                                BOOL fRet;
                                
                                fRet = BackLightSetState(pBKLinfo->dwPddContext, SupportedDx);

                                // above should always succeed
                                ASSERT(fRet);

                                // keep display driver on while backlight is on:
                                if(D0 == SupportedDx)
                                {   
                                    PTCHAR pszDevice;       // to hold device name (GUID + interface name)                                    
                                    UINT uMaxDeviceBytes;   // memory allocated to hold device name

                                    // allow space for null terminator + separating '\':
                                    uMaxDeviceBytes = (sizeof(PMCLASS_DISPLAY) + sizeof(pBKLinfo->szDisplayInterface) + 2*sizeof(TCHAR));
                                    pszDevice = (PTCHAR)LocalAlloc(0, uMaxDeviceBytes);
                                    if(pszDevice != NULL)
                                    {
                                        // copy null-terminated GUID string
                                        HRESULT hr = StringCbCopy(pszDevice, uMaxDeviceBytes, PMCLASS_DISPLAY);
                                        ASSERT(SUCCEEDED(hr)); // This should never fail
                                        
                                        // concatenate '\' separator + display interface name:
                                        if (FAILED(StringCbCat(pszDevice, uMaxDeviceBytes, TEXT("\\")))) 
                                        {
                                            dwErr = ERROR_INSUFFICIENT_BUFFER;
                                        }                                        
                                        else if (FAILED(StringCbCat(pszDevice, uMaxDeviceBytes, pBKLinfo->szDisplayInterface))) 
                                        {
                                            dwErr = ERROR_INSUFFICIENT_BUFFER;
                                        }      
                                        else
                                        {
                                            pBKLinfo->hDDIPowerReq = SetPowerRequirement(pszDevice, D0, POWER_NAME, NULL, 0);
                                        }
                                        LocalFree(pszDevice);
                                    }
                                }
                                else
                                {
                                    ReleasePowerRequirement(pBKLinfo->hDDIPowerReq);
                                }
                                pBKLinfo->dwCurState=SupportedDx;
                                
                                // tell pm which state we went to:
                                *(PCEDEVICE_POWER_STATE) lpOutBuf = SupportedDx;
                                *lpBytesReturned = sizeof(CEDEVICE_POWER_STATE);

                                dwErr = ERROR_SUCCESS;
                                DEBUGMSG(ZONE_BACKLIGHT, (TEXT("IOCTL_POWER_SET to D%u \r\n"), ReqDx));
                                
                            }
                            else
                            {
                                DEBUGMSG(ZONE_BACKLIGHT, (TEXT("Unsupported state request D%u\r\n"), ReqDx));
                            }
                        }
                        else 
                        {
                            DEBUGMSG(ZONE_BACKLIGHT, (TEXT("Invalid state request D%u\r\n"), ReqDx));
                        }
                    }
                    __except(EXCEPTION_EXECUTE_HANDLER) 
                    {
                        DEBUGMSG(ZONE_BACKLIGHT, (TEXT("Exception in ioctl\r\n")));
                    }
                }
                break;

        case IOCTL_POWER_GET: // gets the current device power state
               DEBUGMSG(ZONE_BACKLIGHT,(TEXT("BKL: Received IOCTL_POWER_GET\r\n")));
                if (lpOutBuf != NULL && nOutBufSize >= sizeof(CEDEVICE_POWER_STATE)) 
                {
                    __try 
                    {
                        CEDEVICE_POWER_STATE   CurrentDx;   

                        CurrentDx = pBKLinfo->dwCurState; 
                        *(PCEDEVICE_POWER_STATE)lpOutBuf = CurrentDx;  

                        dwErr = ERROR_SUCCESS;

                        DEBUGMSG(ZONE_BACKLIGHT, (TEXT("IOCTL_POWER_GET: passing back %u\r\n"), CurrentDx));  
                    }
                    __except(EXCEPTION_EXECUTE_HANDLER) 
                    {
                        DEBUGMSG(ZONE_BACKLIGHT, (TEXT("Exception in ioctl\r\n")));
                    }
                }

            break;
        
        default:     
            dwErr = BacklightIOControl(pBKLinfo->dwPddContext, dwIoControlCode, lpInBuf, 
                               nInBufSize, lpOutBuf, nOutBufSize, 
                               lpBytesReturned);
            DEBUGMSG(ZONE_BACKLIGHT,(TEXT("%s: Unsupported IOCTL code %u\r\n"), dwIoControlCode));
            break;
    }

    SetLastError(dwErr);
    if(dwErr != ERROR_SUCCESS) 
    {
        return FALSE;
    } 
    else 
    {
       return TRUE;
    }

}


//------------------------------------------------------------------------------

BOOL WINAPI DllMain(HANDLE hinstDll, ULONG Reason, LPVOID Reserved)
{
    switch(Reason) {
    case DLL_PROCESS_ATTACH:
#ifdef RETAIL_DEBUG
        RETAILREGISTERZONES((HMODULE)hinstDll);
#endif
        DEBUGREGISTER((HMODULE)hinstDll);
        DEBUGMSG(ZONE_BACKLIGHT, (TEXT("DllMain(): dll attach.\r\n")));

        // don't need thread attach/detach messages
        DisableThreadLibraryCalls ((HMODULE)hinstDll);    
        break;
        
    case DLL_PROCESS_DETACH:
        DEBUGMSG(ZONE_BACKLIGHT, (TEXT("DllMain(): dll detach.\r\n")));
        break;
    }
    return TRUE;
}