misc.cpp

windows mobile RIL软件

/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.
Copyright (c) 1995-1999  Microsoft Corporation

Module Name:

misc.cpp

Abstract:


Notes:


--*/


#include "precomp.h"

#ifdef RIL_ALLOW_UNICODE_PBENTRIES
#define ALLOW_UNICODE_PB_ENTRIES TRUE
#else
#define ALLOW_UNICODE_PB_ENTRIES FALSE
#endif

#if defined(OEM1_DRIVER) || defined(OEM2_DRIVER) || defined(EMP_DRIVER)
extern BOOL g_bRadioOff;
#endif

extern RILLOCATIONINFO g_rliLocationInfo;
extern BOOL g_fInitialLocationInfoReceived;

//
// Equipment states
//
#ifdef PHILIP_DRIVER
static const DWORD g_rgdwEquipmentStates[] =
{
    -1,     // RIL_EQSTATE_UNKNOWN
    4,      // RIL_EQSTATE_MINIMUM
    1,      // RIL_EQSTATE_FULL
    4,      // RIL_EQSTATE_DISABLETX
    4,      // RIL_EQSTATE_DISABLERX
    4,      // RIL_EQSTATE_DISABLETXANDRX
};
#else
static const DWORD g_rgdwEquipmentStates[] =
{
    -1,     // RIL_EQSTATE_UNKNOWN
    0,      // RIL_EQSTATE_MINIMUM
    1,      // RIL_EQSTATE_FULL
    2,      // RIL_EQSTATE_DISABLETX
    3,      // RIL_EQSTATE_DISABLERX
    4,      // RIL_EQSTATE_DISABLETXANDRX
};
#endif
#define NUM_EQSTATES    (sizeof(g_rgdwEquipmentStates) / sizeof(DWORD))


//
// Phonebook storage locations
//
static const LPCSTR g_rgszPBLocations[] =
{
    "",             // RIL_PBLOC_UNKNOWN
    "EN",           // RIL_PBLOC_SIMEMERGENCY
    "FD",           // RIL_PBLOC_SIMFIXDIALING
    "LD",           // RIL_PBLOC_SIMLASTDIALING
    "ON",           // RIL_PBLOC_OWNNUMBERS
#ifdef OEM1_DRIVER
    "MT",           // RIL_PBLOC_SIMPHONEBOOK (MT is used for TI phonebook)
#else
    "SM",           // RIL_PBLOC_SIMPHONEBOOK   (Used by OEM2 and Wavecom)
#endif
};
#define NUM_PBLOCS     (sizeof(g_rgszPBLocations) / sizeof(LPCSTR))


//
// Bit error rates
//
static const DWORD g_rgdwBitErrorRates[] =
{
    14,     // 0
    28,     // 1
    57,     // 2
    113,    // 3
    226,    // 4
    453,    // 5
    905,    // 6
    1810,   // 7
};
#define NUM_BITERRORRATES     (sizeof(g_rgdwBitErrorRates) / sizeof(DWORD))


//
// Restricted SIM commands
//
static const DWORD g_rgdwRestrictedSIMCmds[] =
{
    -1,     // 0
    176,    // RIL_SIMCMD_READBINARY
    178,    // RIL_SIMCMD_READRECORD
    192,    // RIL_SIMCMD_GETRESPONSE
    214,    // RIL_SIMCMD_UPDATEBINARY
    220,    // RIL_SIMCMD_UPDATERECORD
    242,    // RIL_SIMCMD_STATUS
};
#define NUM_RESTRICTEDSIMCMDS   (sizeof(g_rgdwRestrictedSIMCmds) / sizeof(DWORD))


//
//
//
static const DWORD g_rgdwSIMToolkitTermCauses[] =
{
    -1,     // 0
    0,      // RIL_SIMTKITTERMCAUSE_USERSTOPPEDREDIAL
    1,      // RIL_SIMTKITTERMCAUSE_ENDOFREDIAL
    2,      // RIL_SIMTKITTERMCAUSE_USERENDEDSESSION
};
#define NUM_SIMTOOLKITTERMCAUSES   (sizeof(g_rgdwSIMToolkitTermCauses) / sizeof(DWORD))


//
//
//
HRESULT ParseGetEquipmentInfo(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetEquipmentInfo);
    RILEQUIPMENTINFO* prei = NULL;
#ifdef RIL_WATSON_REPORT
    RILEQUIPMENTINFO* preiCache = &(g_RilInfoCache.rileiEquipmentInfo);
#endif // RIL_WATSON_REPORT
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

    prei = (RILEQUIPMENTINFO*)AllocBlob(sizeof(RILEQUIPMENTINFO));
    if (!prei) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }
    memset(prei, 0x00, sizeof(RILEQUIPMENTINFO));
    prei->cbSize = sizeof(RILEQUIPMENTINFO);

#ifdef RIL_WATSON_REPORT
    // Clear equipment info cache
    memset(preiCache, 0x00, sizeof(RILEQUIPMENTINFO));
    preiCache->cbSize = sizeof(RILEQUIPMENTINFO);
#endif // RIL_WATSON_REPORT

    // Parse "<prefix><manufacturer_id><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                                                       ||
        !ParseUnquotedString(szRsp, '\r', prei->szManufacturer, MAXLENGTH_EQUIPINFO, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    prei->dwParams |= RIL_PARAM_EI_MANUFACTURER;

#ifdef RIL_WATSON_REPORT
    // Copy to cache
    strncpy(preiCache->szManufacturer, prei->szManufacturer, MAXLENGTH_EQUIPINFO);
    preiCache->dwParams |= RIL_PARAM_EI_MANUFACTURER;
#endif // RIL_WATSON_REPORT

    // Parse "<prefix><model_id><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                                                ||
        !ParseUnquotedString(szRsp, '\r', prei->szModel, MAXLENGTH_EQUIPINFO, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    prei->dwParams |= RIL_PARAM_EI_MODEL;

#ifdef RIL_WATSON_REPORT
    // Copy to cache
    strncpy(preiCache->szModel, prei->szModel, MAXLENGTH_EQUIPINFO);
    preiCache->dwParams |= RIL_PARAM_EI_MODEL;
#endif // RIL_WATSON_REPORT

    // Parse "<prefix><revision_id><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                                                   ||
        !ParseUnquotedString(szRsp, '\r', prei->szRevision, MAXLENGTH_EQUIPINFO, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    prei->dwParams |= RIL_PARAM_EI_REVISION;

#ifdef RIL_WATSON_REPORT
    // Copy to cache
    strncpy(preiCache->szRevision, prei->szRevision, MAXLENGTH_EQUIPINFO);
    preiCache->dwParams |= RIL_PARAM_EI_REVISION;
#endif // RIL_WATSON_REPORT

    // Parse "<prefix><serial_number><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                                                       ||
        !ParseUnquotedString(szRsp, '\r', prei->szSerialNumber, MAXLENGTH_EQUIPINFO, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }
    prei->dwParams |= RIL_PARAM_EI_SERIALNUMBER;

#ifdef RIL_WATSON_REPORT
    // Copy to cache
    strncpy(preiCache->szSerialNumber, prei->szSerialNumber, MAXLENGTH_EQUIPINFO);
    preiCache->dwParams |= RIL_PARAM_EI_SERIALNUMBER;
#endif // RIL_WATSON_REPORT

    pBlob = (void*)prei;
    cbBlob = sizeof(RILEQUIPMENTINFO);

Error:
    if (FAILED(hr)) {
        FreeBlob(prei);
    }
    return hr;
}


//
//
//
HRESULT RILDrv_GetEquipmentInfo(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetEquipmentInfo);
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

#ifdef OEM1_DRIVER
    if (!QueueCmd(pHandle, "AT+CGMI;+CGMM;+CGMR;D*#06#\r", CMDOPT_NONE, APIID_GETEQUIPMENTINFO,
#else
    if (!QueueCmd(pHandle, "AT+CGMI;+CGMM;+CGMR;+CGSN\r", CMDOPT_NONE, APIID_GETEQUIPMENTINFO,
#endif // OEM1_DRIVER
                  ParseGetEquipmentInfo, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}

//
// Helper function to fill RILEQUIPMENTSTATE structure and implement
// driver-specific RIL_RADIOSUPPORT_* mapping.
//
void FillEquipmentStateStruct(RILEQUIPMENTSTATE * pres, DWORD dwEqState)
{
    DEBUGCHK(NULL != pres);

    memset(pres, 0x00, sizeof(RILEQUIPMENTSTATE));

    pres->cbSize = sizeof(RILEQUIPMENTSTATE);
    pres->dwParams = RIL_PARAM_EQUIPMENTSTATE_ALL;
    pres->dwEqState = dwEqState;
    pres->dwReadyState = g_dwReadyState;
    if (RIL_EQSTATE_UNKNOWN == dwEqState)
    {
        pres->dwRadioSupport = RIL_RADIOSUPPORT_UNKNOWN;
    }
    else
    {
        pres->dwRadioSupport = (dwEqState == RIL_EQSTATE_FULL) ? RIL_RADIOSUPPORT_ON : RIL_RADIOSUPPORT_OFF;
    }
}

//
//
//
HRESULT ParseGetEquipmentState(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetEquipmentState);
    UINT nValue;
    DWORD dwState;
    RILEQUIPMENTSTATE * pres = NULL;
    UINT i;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

    pres = (RILEQUIPMENTSTATE*)AllocBlob(sizeof(RILEQUIPMENTSTATE));
    if (!pres) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }

    // Parse "<prefix>+CFUN: <state><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                  ||
        !MatchStringBeginning(szRsp, "+CFUN: ", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)         ||
        !ParseRspPostfix(szRsp, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }

    for (i = 0; i < NUM_EQSTATES; i++) {
        if (nValue == g_rgdwEquipmentStates[i]) {
            dwState = i;
            break;
        }
    }
    if (NUM_EQSTATES == i) {
        // We couldn't match the response with anything
        dwState = RIL_EQSTATE_UNKNOWN;
    }

    FillEquipmentStateStruct(pres, dwState);

    pBlob = (void*)pres;
    cbBlob = pres->cbSize;

#ifdef OEM2_DRIVER
    g_bRadioOff = dwState == RIL_EQSTATE_MINIMUM;
#endif

Error:
    if (FAILED(hr)) {
        FreeBlob(pres);
    }
    return hr;
}


//
//
//
HRESULT RILDrv_GetEquipmentState(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetEquipmentState);
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    if (!QueueCmd(pHandle, "AT+CFUN?\r", CMDOPT_IGNORERADIOOFF, APIID_GETEQUIPMENTSTATE, ParseGetEquipmentState, NULL, hr)) {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}


//
//
//
HRESULT RILDrv_SetEquipmentState(DWORD dwParam, DWORD dwEquipmentState)
{
    FUNCTION_TRACE(RILDrv_SetEquipmentState);
    DEBUGCHK(NUM_EQSTATES > dwEquipmentState);

    DWORD dwCmdOpt = CMDOPT_NONE;

    char szCmd[MAX_PATH];
    HRESULT hr = S_OK;
    CNotificationData * pnd = NULL;
    RILEQUIPMENTSTATE res;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle) {
        hr = E_FAIL;
        goto Error;
    }

    if (RIL_EQSTATE_UNKNOWN == dwEquipmentState) {
        hr = E_INVALIDARG;
        goto Error;

    }
	NKDbgPrintfW(_T("RILDrv_SetEquipmentState(%u)\r\n"), dwEquipmentState);

#ifdef EMP_DRIVER
    if (RIL_EQSTATE_DISABLETX == dwEquipmentState || RIL_EQSTATE_DISABLERX == dwEquipmentState)
    {
        hr = E_NOTIMPL;
        goto Error;
    }
#endif

    FillEquipmentStateStruct(&res, dwEquipmentState);
    if (res.dwRadioSupport == RIL_RADIOSUPPORT_OFF)
    {
        // We'll be turning the radio off
        res.dwReadyState = 0;
        g_dwGPRSRegStatus = RIL_REGSTAT_UNKNOWN;
        g_dwRegStatus = RIL_REGSTAT_UNKNOWN;

#ifdef RIL_WATSON_REPORT
        // Reset registration status in info cache.
        g_RilInfoCache.dwRegStatus = RIL_REGSTAT_UNKNOWN;
        g_RilInfoCache.dwGPRSRegStatus = RIL_REGSTAT_UNKNOWN;
#endif // RIL_WATSON_REPORT

    }

    pnd = new CNotificationData;
    if (pnd && !pnd->InitFromRealBlob(RIL_NOTIFY_RADIOEQUIPMENTSTATECHANGED, (void*)&res, res.cbSize))
    {
        delete pnd;
        pnd = NULL;
    }

    // If this command will turn on the radio, then
    // note this in the command option. If this option
    // is not set for the SETEQUIPMENTSTATE command,
    // then it is assumed that it turns off the radio.
    if (RIL_RADIOSUPPORT_ON == res.dwRadioSupport)
    {
        dwCmdOpt |= CMDOPT_SETRADIOON;

#if defined(WAVECOM_DRIVER) || defined(OEM1_DRIVER) || defined(OEM2_DRIVER) || defined(EMP_DRIVER) || defined(PHILIP_DRIVER)
        // HW-SPECIFIC: WaveCom hardware always resets after AT+CFUN=<n>

        dwCmdOpt |= CMDOPT_REINIT;
#endif // WAVECOM_DRIVER
#if defined(OEM2_DRIVER) || defined(EMP_DRIVER)
       if (FALSE ==  g_bRadioOff)
       {
            // The radio is already on, no need to turn it on again, particularly since we won't get the CPINN
            // notification again, and this will cause the command thread to time out waiting for it.
            dwCmdOpt |= CMDOPT_NOOP;
       }
#endif

    }

    // This command is OK to send, even if the radio is "off".
    dwCmdOpt |= CMDOPT_IGNORERADIOOFF;

    // Set a registry key to save the new state of the radio in a location that persists across rebooting
    (void)SetRegistryDWORD(RIL_LAST_EQUIPMENT_STATE_ROOT, RIL_LAST_EQUIPMENT_STATE_KEY, RIL_LAST_EQUIPMENT_STATE_VALUE, dwEquipmentState);

#if defined(RIL_ENABLE_SIMTK) && defined(OEM1_DRIVER)
    if (dwCmdOpt & CMDOPT_SETRADIOON)
    {
        // We must send the terminal profile string along when we turn on the radio
        (void)_snprintfz(szCmd, MAX_PATH, "AT%%SATC=1,0901FF7F00000010;+CFUN=%u\r", g_rgdwEquipmentStates[dwEquipmentState]);
    }
    else
#endif
    {
#if defined(OEM1_DRIVER) || defined(OEM2_DRIVER) || defined(EMP_DRIVER)
        if(RIL_EQSTATE_MINIMUM == dwEquipmentState)
        {
            // When turning the radio off, first force a GPRS detach in case the radio doesn't do so automatically
            DEBUGCHK(0 == g_rgdwEquipmentStates[dwEquipmentState]);