rilmain.cpp

windows mobile RIL软件

    {                                                       \
        PARAMSTYPE##* pParams = (##PARAMSTYPE##*)pBufIn;    \
        if (pBufIn && dwLenIn >= sizeof(PARAMSTYPE)) {      \
            *phr = APICall;                                 \
            dwOutUsed = sizeof(HRESULT);                    \
            fRet = TRUE;                                    \
        }                                                   \
    }

#define CALLDRVAPI_OPTVARPARAMS(PARAMSTYPE, APICall)        \
    {                                                       \
        PARAMSTYPE##* pParams = (##PARAMSTYPE##*)pBufIn;    \
        if (!pBufIn || dwLenIn >= sizeof(PARAMSTYPE)) {     \
            *phr = APICall;                                 \
            dwOutUsed = sizeof(HRESULT);                    \
            fRet = TRUE;                                    \
        }                                                   \
    }

#define CALLDRVAPI_ARRAY(ELEMTYPE, APICall)                 \
    {                                                       \
        ELEMTYPE##* pParams = (##ELEMTYPE##*)pBufIn;        \
        if (pBufIn) {                                       \
            *phr = APICall;                                 \
            dwOutUsed = sizeof(HRESULT);                    \
            fRet = TRUE;                                    \
        }                                                   \
    }

#define CALLDRVAPI(APIName)                                 \
    *phr = APIName(dwOpenData);                             \
    dwOutUsed = sizeof(HRESULT);                            \
    fRet = TRUE;


//
//
//
BOOL RIL_IOControl(DWORD dwOpenData, DWORD dwCode, PBYTE pBufIn, DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut,
                   PDWORD pdwActualOut)
{
    FUNCTION_TRACE(RIL_IOControl);
    DEBUGCHK(dwOpenData != 0);

    DWORD dwOutUsed = 0;
    BOOL fRet = FALSE;

#ifdef RIL_ALLOW_DRIVER_REMOVAL_TESTING
    if (!g_pDeviceAllowDriverRemovalTesting)
    {
        ASSERT(!"RIL_IOControl should not be called after the driver has gone away");
        return FALSE;
    }
#endif

    CRilInstanceHandle* pHandle = (CRilInstanceHandle*)dwOpenData;
    if (!pHandle)
    {
        goto Error;
    }
#ifdef PHILIP_DRIVER

	 //Alan Luo : for debug message
	 //RIL_IOControl_Show(dwCode, pBufOut, dwLenOut);
	 //

#endif

    if(SUCCEEDED(ValidateAPIPermission(TEXT("RILGSM"), TEXT("IOControl"), VAP_TRUST_CALLER)))  // Perform security check
    {
        switch (dwCode)
        {
        // CPM is ready for us to register with it
        case IOCTL_RIL_REGISTERWITHCPM:
            {
#ifdef RIL_RADIO_RESILIENCE
                // no longer supported
                fRet = FALSE;
#else
                CRilHandle* pRilDevice = pHandle->GetDevice();
                DEBUGCHK(NULL != pRilDevice);
                fRet = pRilDevice->RegisterWithCPM();
#endif // ! RIL_RADIO_RESILIENCE
            }
            break;

            // This handle will be used for an emergency call - it should be marked as preferred and RIL should be
            //    switched into "emergency mode"
        case IOCTL_RIL_EMERGENCYSTATUS:
            fRet = pHandle->MakePreferred();
            break;

            // Initialize notification delivery
        case IOCTL_RIL_INITNOTIFICATIONS:
            if (pBufIn)
            {
                fRet = pHandle->CreateNotificationQueue((LPCTSTR)pBufIn, pBufOut, dwLenOut, &dwOutUsed);
            }
            break;

            // Get next RIL notification
        case IOCTL_RIL_GETNEXTNOTIFICATION:
            {
                RILDRVNOTIFICATION* pResult = (RILDRVNOTIFICATION*)pBufOut;
                if (pBufOut && dwLenOut >= sizeof(RILDRVNOTIFICATION) &&
                    SUCCEEDED(RILDrv_GetNextNotification(dwOpenData, pResult)))
                {

                    dwOutUsed = pResult->cbSize;
                    fRet = TRUE;
                }
                break;
            }

            // RIL_GetSerialPortStatistics()
        case IOCTL_RIL_GETSERIALPORTSTATISTICS:
            {
                RILSERIALPORTSTATS* pResult = (RILSERIALPORTSTATS*)pBufOut;
                if (pBufOut && dwLenOut >= sizeof(RILSERIALPORTSTATS) &&
                    SUCCEEDED(RILDrv_GetSerialPortStatistics(dwOpenData, pResult)))
                {

                    dwOutUsed = sizeof(RILSERIALPORTSTATS);
                    fRet = TRUE;
                }
                break;
            }

            // RIL_GetDriverVersion()
        case IOCTL_RIL_GETDRIVERVERSION:
            {
                DWORD *pResult = (DWORD *)pBufOut;
                if (pBufOut && dwLenOut >= sizeof(DWORD))
                {
                    // For now, versioning is going to be done manually on an as needed basis
                    *pResult = 0x00020002;
                    dwOutUsed = sizeof(DWORD);
                    fRet = TRUE;
                }
                break;
            }

#ifdef RIL_LAST_ERROR
        case IOCTL_RIL_GETLASTERROR:
            {
                DWORD *pResult = (DWORD *)pBufOut;
                if (pBufOut && dwLenOut >= sizeof(DWORD))
                {
                    // Give them back the error
                    *pResult = g_dwLastError;
                    dwOutUsed = sizeof(DWORD);
                    fRet = TRUE;
                }
                break;
            }
            break;
#endif
        case IOCTL_PSL_NOTIFY:
            {
                pHandle->CancelNotifications();
                fRet = TRUE;
                break;
            }

        case IOCTL_RIL_GETSERIALPORTHANDLEFROMCONTEXTID:
            {
                if ( pBufIn && (dwLenIn == sizeof(DWORD)) )
                {
                    if ( SUCCEEDED(RILDrv_GetSerialPortHandleFromContextID(*((DWORD*)pBufIn), (TCHAR*) pBufOut, dwLenOut, &dwOutUsed)))
                    {
                        fRet = TRUE;
                    }
                }
                break;
            }

        case IOCTL_RIL_GETVTSERIALPORTHANDLE:
            {
                if ( SUCCEEDED(RILDrv_GetVTSerialPortHandle((TCHAR*) pBufOut, dwLenOut, &dwOutUsed)))
                {
                    fRet = TRUE;
                }
                break;
            }

            // Other RIL_ APIs
        default:
            {
                HRESULT* phr = (HRESULT*)pBufOut;
                if (!pBufOut || dwLenOut < sizeof(HRESULT))
                {
                    goto Error;
                }

                switch (dwCode)
                {
#ifdef OEM1_DRIVER_PM
                // RIL saving power management io control
                case IOCTL_RIL_POWERSUSPEND:
                    CALLDRVAPI(RILDrv_EnablePowerSavings);
                    break;

                // RIL disable saving power management io control
                case IOCTL_RIL_POWERRESUME:
                    CALLDRVAPI(RILDrv_DisablePowerSavings);
                    break;
#endif  // OEM1_DRIVER_PM
                // RIL_GetSubscriberNumbers()
                case IOCTL_RIL_GETSUBSCRIBERNUMBERS:
					DEBUGMSG(ZONE_INFO, (TEXT("Rilmain :entry of RIL_GetSubscriberNumbers\r\n")));
                    CALLDRVAPI(RILDrv_GetSubscriberNumbers);
                    break;

                    // RIL_GetOperatorList()
                case IOCTL_RIL_GETOPERATORLIST:
                    CALLDRVAPI(RILDrv_GetOperatorList);
                    break;

                    // RIL_GetPreferredOperatorList()
                case IOCTL_RIL_GETPREFERREDOPERATORLIST:
                    CALLDRVAPI_PARAMS(DWORD, RILDrv_GetPreferredOperatorList(dwOpenData, *pParams));
                    break;

                    // RIL_AddPreferredOperator()
                case IOCTL_RIL_ADDPREFERREDOPERATOR:
                    CALLDRVAPI_PARAMS(ADDPREFERREDOPERATOR_PARAMS, RILDrv_AddPreferredOperator(dwOpenData, \
                                                                                                            pParams->dwIndex, &pParams->ronOperatorNames));
                    break;

                    // RIL_RemovePreferredOperator()
                case IOCTL_RIL_REMOVEPREFERREDOPERATOR:
                    CALLDRVAPI_PARAMS(DWORD, RILDrv_RemovePreferredOperator(dwOpenData, *pParams));
                    break;

                    // RIL_GetCurrentOperator()
                case IOCTL_RIL_GETCURRENTOPERATOR:
                    CALLDRVAPI_PARAMS(DWORD, RILDrv_GetCurrentOperator(dwOpenData, *pParams));
                    break;

                    // RIL_GetAllOperatorsList()
                case IOCTL_RIL_GETALLOPERATORSLIST:
                    CALLDRVAPI(RILDrv_GetAllOperatorsList);
                    break;

                    // RIL_RegisterOnNetwork()
                case IOCTL_RIL_REGISTERONNETWORK:
                    CALLDRVAPI_PARAMS(REGISTERONNETWORK_PARAMS, RILDrv_RegisterOnNetwork(dwOpenData, pParams->dwMode, \
                                                                                                      &pParams->ronOperatorNames));
                    break;

                    // RIL_UnregisterFromNetwork()
                case IOCTL_RIL_UNREGISTERFROMNETWORK:
                    CALLDRVAPI(RILDrv_UnregisterFromNetwork);
                    break;

                    // RIL_GetRegistrationStatus()
                case IOCTL_RIL_GETREGISTRATIONSTATUS:
                    CALLDRVAPI(RILDrv_GetRegistrationStatus);
                    break;

                    // RIL_GetCallerIdSettings()
                case IOCTL_RIL_GETCALLERIDSETTINGS:
					DEBUGMSG(ZONE_INFO, (TEXT("Rilmain :entry of RIL_GetCallerIdSettings\r\n")));
                    CALLDRVAPI(RILDrv_GetCallerIdSettings);
                    break;

                    // RIL_SetCallerIdStatus()
                case IOCTL_RIL_SETCALLERIDSTATUS:
					DEBUGMSG(ZONE_INFO, (TEXT("Rilmain :entry of RIL_SetCallerIdStatus\r\n")));
                    CALLDRVAPI_PARAMS(DWORD, RILDrv_SetCallerIdStatus(dwOpenData, *pParams));
                    break;

                    // RIL_GetHideIdSettings()
                case IOCTL_RIL_GETHIDEIDSETTINGS:
                    CALLDRVAPI(RILDrv_GetHideIdSettings);
                    break;

                    // RIL_SetHideIdStatus()
                case IOCTL_RIL_SETHIDEIDSTATUS:
                    CALLDRVAPI_PARAMS(DWORD, RILDrv_SetHideIdStatus(dwOpenData, *pParams));
                    break;

                    // RIL_GetDialedIdSettings()
                case IOCTL_RIL_GETDIALEDIDSETTINGS:
					DEBUGMSG(ZONE_INFO, (TEXT("Rilmain :entry of RIL_GetDialedIdSettings\r\n")));
                    CALLDRVAPI(RILDrv_GetDialedIdSettings);
                    break;

                    // RIL_SetDialedIdStatus()
                case IOCTL_RIL_SETDIALEDIDSTATUS:
					DEBUGMSG(ZONE_INFO, (TEXT("Rilmain :entry of RIL_SetDialedIdStatus\r\n")));
					CALLDRVAPI_PARAMS(DWORD, RILDrv_SetDialedIdStatus(dwOpenData, *pParams));
                    break;

                    // RIL_GetHideConnectedIdSettings()
                case IOCTL_RIL_GETHIDECONNECTEDIDSETTINGS:
                    CALLDRVAPI(RILDrv_GetHideConnectedIdSettings);
                    break;

                    // RIL_SetHideConnectedIdStatus()
                case IOCTL_RIL_SETHIDECONNECTEDIDSTATUS:
                    CALLDRVAPI_PARAMS(DWORD, RILDrv_SetHideConnectedIdStatus(dwOpenData, *pParams));
                    break;

                    // RIL_GetClosedGroupSettings()
                case IOCTL_RIL_GETCLOSEDGROUPSETTINGS:
                    CALLDRVAPI(RILDrv_GetClosedGroupSettings);
                    break;

                    // RIL_SetClosedGroupSettings()
                case IOCTL_RIL_SETCLOSEDGROUPSETTINGS:
                    CALLDRVAPI_PARAMS(RILCLOSEDGROUPSETTINGS, RILDrv_SetClosedGroupSettings(dwOpenData, pParams));
                    break;

                    // RIL_GetCallForwardingSettings()
                case IOCTL_RIL_GETCALLFORWARDINGSETTINGS:
					DEBUGMSG(ZONE_INFO, (TEXT("Rilmain :entry of RIL_GetCallForwardingSettings\r\n")));
					CALLDRVAPI_PARAMS(GETCALLFORWARDING_PARAMS, RILDrv_GetCallForwardingSettings(dwOpenData, pParams->dwReason, pParams->dwInfoClasses));
                    break;

                    // RIL_AddCallForwarding()
                case IOCTL_RIL_ADDCALLFORWARDING:
					DEBUGMSG(ZONE_INFO, (TEXT("Rilmain :entry of RIL_AddCallForwarding\r\n")));
					CALLDRVAPI_PARAMS(ADDCALLFORWARDING_PARAMS, RILDrv_AddCallForwarding(dwOpenData, pParams->dwReason, \
                                                                                                      &pParams->rcfsSettings));
                    break;

                    // RIL_RemoveCallForwarding()
                case IOCTL_RIL_REMOVECALLFORWARDING:
                    CALLDRVAPI_PARAMS(REMOVECALLFORWARDING_PARAMS, RILDrv_RemoveCallForwarding(dwOpenData, \
                                                                                                            pParams->dwReason, pParams->dwInfoClasses));
                    break;

                    // RIL_SetCallForwardingStatus()
                case IOCTL_RIL_SETCALLFORWARDINGSTATUS:
                    CALLDRVAPI_PARAMS(SETCALLFORWARDINGSTATUS_PARAMS, RILDrv_SetCallForwardingStatus(dwOpenData, \
                                                                                                     pParams->dwReason, \
                                                                                                     pParams->dwInfoClasses, \
                                                                                                     pParams->dwStatus));
                    break;

                    // RIL_GetCallWaitingSettings()
                case IOCTL_RIL_GETCALLWAITINGSETTINGS:
					DEBUGMSG(ZONE_INFO, (TEXT("Rilmain :entry of RIL_GetCallWaitingSettings\r\n")));
					CALLDRVAPI_PARAMS(GETCALLWAITINGSTATUS_PARAMS, RILDrv_GetCallWaitingSettings(dwOpenData, pParams->dwInfoClasses));
                    break;

                    // RIL_SetCallWaitingStatus()
                case IOCTL_RIL_SETCALLWAITINGSTATUS:
					DEBUGMSG(ZONE_INFO, (TEXT("Rilmain :entry of RIL_SetCallWaitingStatus\r\n")));
					CALLDRVAPI_PARAMS(SETCALLWAITINGSTATUS_PARAMS, RILDrv_SetCallWaitingStatus(dwOpenData, \
                                                                                                            pParams->dwInfoClasses, pParams->dwStatus));
                    break;

                    // RIL_SendSupServiceData()
                case IOCTL_RIL_SENDSUPSERVICEDATA:
                    CALLDRVAPI_ARRAY(BYTE, RILDrv_SendSupServiceData(dwOpenData, pParams, dwLenIn));
                    break;

                    // RIL_CancelSupServiceDataSession()
                case IOC