data.cpp

手机RILGSM实现的源代码

/*++
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:

data.cpp

Abstract:


Notes:

Modification                  Tracking
    Date                        Author                  Number                  Description of changes
    ----------    --------------    ---------               ----------------------------
    2007-07-18	    zhaozipeng          WM600010444	    solve muti-connection conflict on TI side

--*/


#include "precomp.h"

//
// Bearer service names
//
static const DWORD g_rgdwBearerSvcNames[] =
{
    -1,     // RIL_BSVCNAME_UNKNOWN
    0,      // RIL_BSVCNAME_DATACIRCUIT_ASYNC_UDI_MODEM
    1,      // RIL_BSVCNAME_DATACIRCUIT_SYNC_UDI_MODEM
    2,      // RIL_BSVCNAME_PADACCESS_ASYNC_UDI
    3,      // RIL_BSVCNAME_PACKETACCESS_SYNC_UDI
    4,      // RIL_BSVCNAME_DATACIRCUIT_ASYNC_RDI
    5,      // RIL_BSVCNAME_DATACIRCUIT_SYNC_RDI
    6,      // RIL_BSVCNAME_PADACCESS_ASYNC_RDI
    7,      // RIL_BSVCNAME_PACKETACCESS_SYNC_RDI
};
#define NUM_BEARERSVCNAMES  (sizeof(g_rgdwBearerSvcNames) / sizeof(DWORD))


//
// Bearer service connection elements
//
static const DWORD g_rgdwBearerSvcConnElems[] =
{
    -1,     // RIL_BSVCCE_UNKNOWN
    0,      // RIL_BSVCCE_TRANSPARENT
    1,      // RIL_BSVCCE_NONTRANSPARENT
    2,      // RIL_BSVCCE_BOTH_TRANSPARENT
    3,      // RIL_BSVCCE_BOTH_NONTRANSPARENT
};
#define NUM_BEARERSVCCONNELEMS  (sizeof(g_rgdwBearerSvcConnElems) / sizeof(DWORD))


static const LISTVALUEMAP g_DataCompDirection[] =
{
    {0, RIL_DATACOMPDIR_NONE},
    {1, RIL_DATACOMPDIR_TRANSMIT},
    {2, RIL_DATACOMPDIR_RECEIVE},
    {3, RIL_DATACOMPDIR_BOTH},
};
#define NUM_DATACOMPDIRECTION (sizeof(g_DataCompDirection) / sizeof(LISTVALUEMAP))

static const LISTVALUEMAP g_DataCompNegotiation[] =
{
    {0, RIL_DATACOMP_OPTIONAL},
    {1, RIL_DATACOMP_REQUIRED},
};
#define NUM_DATACOMPNEGOTIATION (sizeof(g_DataCompNegotiation) / sizeof(LISTVALUEMAP))



//
// Error correction values: Original Request
//
static const LISTVALUEMAP g_ErrorCorrectionOrigRqst[] =
{
    {0, RIL_ECMODE_DIRECT},
    {1, RIL_ECMODE_BUFFERED},
    {2, RIL_ECMODE_NODETECT},
    {3, RIL_ECMODE_DETECT},
    {4, RIL_ECMODE_ALTERNATIVE},
};
#define NUM_ERRORCORRECTIONORIGRQST (sizeof(g_ErrorCorrectionOrigRqst) / sizeof(LISTVALUEMAP))

//
// Error correction values: Original Fallback
//
static const LISTVALUEMAP g_ErrorCorrectionOrigFbk[] =
{
    {0, RIL_ECMODE_OPTIONAL_USEBUFFERED},
    {1, RIL_ECMODE_OPTIONAL_USEDIRECT},
    {2, RIL_ECMODE_REQUIRED},
    {3, RIL_ECMODE_REQUIRED_LAPMONLY},
    {4, RIL_ECMODE_REQUIRED_ALTERNATIVEONLY},
};
#define NUM_ERRORCORRECTIONORIGFBK (sizeof(g_ErrorCorrectionOrigFbk) / sizeof(LISTVALUEMAP))

//
// Error correction values: Original Fallback
//
static const LISTVALUEMAP g_ErrorCorrectionAnsFbk[] =
{
    {0, RIL_ECMODE_DIRECT},
    {1, RIL_ECMODE_BUFFERED},
    {2, RIL_ECMODE_OPTIONAL_USEBUFFERED},
    {3, RIL_ECMODE_OPTIONAL_USEDIRECT},
    {4, RIL_ECMODE_REQUIRED},
    {5, RIL_ECMODE_REQUIRED_LAPMONLY},
    {6, RIL_ECMODE_REQUIRED_ALTERNATIVEONLY},
};
#define NUM_ERRORCORRECTIONANSFBK (sizeof(g_ErrorCorrectionAnsFbk) / sizeof(LISTVALUEMAP))

//extern DWORD g_dwActiveGPRSContextID;//zhaozipeng 20070718

//
//
//
static HRESULT ParseGetHSCSDOptions(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetHSCSDOptions);
    UINT nValue;
    UINT i;
    RILHSCSDINFO* prhscsdi = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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


    // Parse "<prefix>+CHST: <rx_timeslots>"
    if (!ParseRspPrefix(szRsp, szRsp)                  ||
        !MatchStringBeginning(szRsp, "+CHST: ", szRsp) ||
        !ParseUIntAndVerifyBelow(szRsp, TRUE, 0, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }
    prhscsdi->dwTranspRxTimeslots = nValue;
    prhscsdi->dwParams |= RIL_PARAM_HSCSDI_TRANSPRXTIMESLOTS;

    // Parse ",<codings><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)   ||
        !ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    // Set all required channel coding bits
    if (!nValue)
    {
        prhscsdi->dwTranspChannelCodings = RIL_HSCSDCODING_ALL;
    }
    else
    {
        for (i = 0 ; i < NUM_HSCSDCODINGS; i++)
        {
            if (nValue & (0x01 << i))
            {
                prhscsdi->dwTranspChannelCodings |= g_rgdwHSCSDCodings[i];
            }
        }
    }
    prhscsdi->dwParams |= RIL_PARAM_HSCSDI_TRANSPCHANNELCODINGS;


    // Parse "<prefix>+CHSN: <aiur>"
    if (!ParseRspPrefix(szRsp, szRsp)                  ||
        !MatchStringBeginning(szRsp, "+CHSN: ", szRsp) ||
        !ParseUIntAndVerifyBelow(szRsp, TRUE, 0, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }
    for (i = 0; i < NUM_HSCSDAIRRATES; i++)
    {
        if (nValue == g_rgdwHSCSDAirRates[i])
        {
            prhscsdi->dwAirInterfaceUserRate = i;
            break;
        }
    }
    if (NUM_HSCSDAIRRATES == i)
    {
        // We couldn't match the response with anything
        prhscsdi->dwAirInterfaceUserRate = RIL_HSCSDAIURATE_UNKNOWN;
    }
    prhscsdi->dwParams |= RIL_PARAM_HSCSDI_AIRINTERFACEUSERRATE;

    // Parse ",<rx_timeslots>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUIntAndVerifyBelow(szRsp, TRUE, 0, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }
    prhscsdi->dwNonTranspRxTimeslots = nValue;
    prhscsdi->dwParams |= RIL_PARAM_HSCSDI_NONTRANSPRXTIMESLOTS;

    // Parse ",<top_rx_timeslots>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }
    prhscsdi->dwRxTimeslotsLimit = (nValue ? nValue : RIL_HSCSDTIMESLOTSLIMIT_NONE);
    prhscsdi->dwParams |= RIL_PARAM_HSCSDI_RXTIMESLOTSLIMIT;

    // Parse ",<codings><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)   ||
        !ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    // Set all required channel coding bits
    if (!nValue)
    {
        prhscsdi->dwNonTranspChannelCodings = RIL_HSCSDCODING_ALL;
    }
    else
    {
        for (i = 0 ; i < NUM_HSCSDCODINGS; i++)
        {
            if (nValue & (0x01 << i))
            {
                prhscsdi->dwNonTranspChannelCodings |= g_rgdwHSCSDCodings[i];
            }
        }
    }
    prhscsdi->dwParams |= RIL_PARAM_HSCSDI_NONTRANSPCHANNELCODINGS;


    // Parse "+<prefix>CHSU: <mode><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                           ||
        !MatchStringBeginning(szRsp, "+CHSU: ", szRsp)          ||
        !ParseUIntAndVerifyAbove(szRsp, TRUE, 2, nValue, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }
    prhscsdi->fAutoSvcLevelUpgrading = !!nValue;
    prhscsdi->dwParams |= RIL_PARAM_HSCSDI_AUTOSVCLEVELUPGRADING;


    pBlob = (void*)prhscsdi;
    cbBlob = sizeof(RILHSCSDINFO);

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


//
//
//
HRESULT RILDrv_GetHSCSDOptions(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetHSCSDOptions);
#if !defined(WAVECOM_DRIVER) || defined(GSM_ATTEST)
    // HW-SPECIFIC: WaveCom hardware doesn't support AT+CHST, AT+CHSN, and AT+CHSU
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle)
    {
        hr = E_FAIL;
        goto Error;
    }

    if (!QueueCmd(pHandle, "AT+CHST?;+CHSN?;+CHSU?\r", CMDOPT_NONE, APIID_GETHSCSDOPTIONS, ParseGetHSCSDOptions,
                  NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
#else  // WAVECOM_DRIVER

    HRESULT hr = E_NOTIMPL;
#endif // WAVECOM_DRIVER

    return hr;
}


//
//
//
HRESULT RILDrv_SetHSCSDOptions(DWORD dwParam, const RILHSCSDINFO* lpHscsdInfo)
{
    FUNCTION_TRACE(RILDrv_SetHSCSDOptions);
#if !defined(WAVECOM_DRIVER) || defined(GSM_ATTEST)
    // HW-SPECIFIC: WaveCom hardware doesn't support AT+CHST, AT+CHSN, and AT+CHSU

    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    UINT nValue;
    UINT i;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpHscsdInfo)
    {
        hr = E_FAIL;
        goto Error;
    }



    // Add "AT+CHST="
    (void)strncpyz(szWalk, "AT+CHST=", MAX_PATH - (szWalk - szCmd));
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    // Add "<rx_timeslots>"
    if (lpHscsdInfo->dwParams & RIL_PARAM_HSCSDI_TRANSPRXTIMESLOTS)
    {
        if (RIL_HSCSDTIMESLOTS_DEFAULT == lpHscsdInfo->dwTranspRxTimeslots)
        {
            nValue = 0;
        }
        else
        {
            nValue = lpHscsdInfo->dwTranspRxTimeslots;
        }

        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", nValue);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    // Add ","
    (void)strncpyz(szWalk, ",", MAX_PATH - (szWalk - szCmd));
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    // Add "<codings>"
    if (lpHscsdInfo->dwParams & RIL_PARAM_HSCSDI_TRANSPCHANNELCODINGS)
    {
        nValue = 0;
        if (RIL_HSCSDCODING_ALL != lpHscsdInfo->dwTranspChannelCodings)
        {
            for (i = 0 ; i < NUM_HSCSDCODINGS; i++)
            {
                if (lpHscsdInfo->dwTranspChannelCodings & g_rgdwHSCSDCodings[i])
                {
                    nValue += (0x01 << i);
                }
            }
            if (!nValue)
            {
                hr = E_INVALIDARG;
                goto Error;
            }
        }

        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", nValue);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }


    // Add ";+CHSN="
    (void)strncpyz(szWalk, ";+CHSN=", MAX_PATH - (szWalk - szCmd));

    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    // Add "<auir>"
    if (lpHscsdInfo->dwParams & RIL_PARAM_HSCSDI_AIRINTERFACEUSERRATE)
    {
        if (RIL_HSCSDAIURATE_UNKNOWN == lpHscsdInfo->dwAirInterfaceUserRate)
        {
            hr = E_INVALIDARG;
            goto Error;
        }

        if (RIL_HSCSDAIURATE_DEFAULT == lpHscsdInfo->dwAirInterfaceUserRate)
        {
            nValue = 0;
        }
        else
        {
            DEBUGCHK(RIL_HSCSDAIURATE_57600 > lpHscsdInfo->dwAirInterfaceUserRate);
            nValue = g_rgdwHSCSDAirRates[lpHscsdInfo->dwAirInterfaceUserRate];
        }

        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", nValue);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    // Add ","
    (void)strncpyz(szWalk, ",", MAX_PATH - (szWalk - szCmd));
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    // Add "<rx_timeslots>"
    if (lpHscsdInfo->dwParams & RIL_PARAM_HSCSDI_NONTRANSPRXTIMESLOTS)
    {
        if (RIL_HSCSDTIMESLOTS_DEFAULT == lpHscsdInfo->dwNonTranspRxTimeslots)
        {
            nValue = 0;
        }
        else
        {
            nValue = lpHscsdInfo->dwNonTranspRxTimeslots;
        }

        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", nValue);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }