data.cpp

ril source code for Windows CE

            }
            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 if (RIL_HSCSDAIURATE_57600 >= lpHscsdInfo->dwAirInterfaceUserRate)
        {
            nValue = g_rgdwHSCSDAirRates[lpHscsdInfo->dwAirInterfaceUserRate];
        }
        else 
        {
            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 ","
    (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);
    }

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

    // Add "<top_rx_timeslots>"
    if (lpHscsdInfo->dwParams & RIL_PARAM_HSCSDI_RXTIMESLOTSLIMIT)
    {
        if (RIL_HSCSDTIMESLOTSLIMIT_NONE == lpHscsdInfo->dwRxTimeslotsLimit)
        {
            nValue = 0;
        }
        else
        {
            nValue = lpHscsdInfo->dwRxTimeslotsLimit;
        }

        (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_NONTRANSPCHANNELCODINGS)
    {
        nValue = 0;
        if (RIL_HSCSDCODING_ALL != lpHscsdInfo->dwNonTranspChannelCodings)
        {
            for (i = 0 ; i < NUM_HSCSDCODINGS; i++)
            {
                if (lpHscsdInfo->dwNonTranspChannelCodings & 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);
    }

    if (lpHscsdInfo->dwParams & RIL_PARAM_HSCSDI_AUTOSVCLEVELUPGRADING)
    {
        // Add ";+CHSU=<mode>"
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), ";+CHSU=%u",
                         (lpHscsdInfo->fAutoSvcLevelUpgrading ? 1 : 0));
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    // Add "<CR>"
    (void)strncpyz(szWalk, "\r", MAX_PATH - (szWalk - szCmd));
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETHSCSDOPTIONS, NULL, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:

    return hr;
}
//
//
//
static HRESULT ParseGetHSCSDCallSettings(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetHSCSDCallSettings);
    UINT nValue;
    UINT i;
    RILCALLHSCSDINFO* prchscsdi = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

    // Parse "<prefix>+CHSC: <rx_timeslots>"
    if (!ParseRspPrefix(szRsp, szRsp)                  ||
        !MatchStringBeginning(szRsp, "+CHSC: ", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }
    prchscsdi->dwRxTimeslots = nValue;
    prchscsdi->dwParams |= RIL_PARAM_CHSCSDI_RXTIMESLOTS;

    // Parse ",<tx_timeslots>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }
    prchscsdi->dwTxTimeslots = nValue;
    prchscsdi->dwParams |= RIL_PARAM_CHSCSDI_TXTIMESLOTS;

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

    // Parse ",<coding><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)   ||
        !ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }
    for (i = 0 ; i < NUM_HSCSDCODINGS; i++)
    {
        if ((0x01 << i) == (int)nValue)
        {
            prchscsdi->dwChannelCoding = g_rgdwHSCSDCodings[i];
            break;
        }
    }
    if (NUM_HSCSDCODINGS == i)
    {
        prchscsdi->dwChannelCoding = RIL_HSCSDCODING_UNKNOWN;
    }
    prchscsdi->dwParams |= RIL_PARAM_CHSCSDI_CHANNELCODING;

    pBlob = (void*)prchscsdi;
    cbBlob = sizeof(RILCALLHSCSDINFO);

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


//
//
//
HRESULT RILDrv_GetHSCSDCallSettings(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetHSCSDCallSettings);

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

    if (!QueueCmd(pHandle, "AT+CHSC\r", CMDOPT_NONE, APIID_GETHSCSDCALLSETTINGS, ParseGetHSCSDCallSettings, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:

    return hr;
}


//
//
//
static HRESULT ParseGetBearerServiceOptions(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetBearerServiceOptions);
    UINT nValue;
    UINT i;
    RILBEARERSVCINFO* prbsi = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

    // Parse "<prefix>+CBST: <speed>"
    if (!ParseRspPrefix(szRsp, szRsp)                  ||
        !MatchStringBeginning(szRsp, "+CBST: ", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }
    for (i = 0; i < NUM_CONNSPEEDS; i++)
    {
        if (nValue == g_rgdwConnSpeeds[i])
        {
            prbsi->dwSpeed = i;
            break;
        }
    }
    if (NUM_CONNSPEEDS == i)
    {
        // We couldn't match the response with anything
        prbsi->dwSpeed = RIL_SPEED_UNKNOWN;
    }
    prbsi->dwParams |= RIL_PARAM_BSI_SPEED;

    // Parse ",<svc_name>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }
    for (i = 0; i < NUM_BEARERSVCNAMES; i++)
    {
        if (nValue == g_rgdwBearerSvcNames[i])
        {
            prbsi->dwServiceName = i;
            break;
        }
    }
    if (NUM_BEARERSVCNAMES == i)
    {
        // We couldn't match the response with anything
        prbsi->dwServiceName = RIL_BSVCNAME_UNKNOWN;
    }
    prbsi->dwParams |= RIL_PARAM_BSI_SERVICENAME;

    // Parse ",<conn_element><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseUInt(szRsp, TRUE, nValue, szRsp)   ||
        !ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }
    for (i = 0; i < NUM_BEARERSVCCONNELEMS; i++)
    {
        if (nValue == g_rgdwBearerSvcConnElems[i])
        {
            prbsi->dwConnectionElement = i;
            break;
        }
    }
    if (NUM_BEARERSVCCONNELEMS == i)
    {
        // We couldn't match the response with anything
        prbsi->dwConnectionElement = RIL_BSVCCE_UNKNOWN;
    }
    prbsi->dwParams |= RIL_PARAM_BSI_CONNECTIONELEMENT;

    pBlob = (void*)prbsi;
    cbBlob = sizeof(RILBEARERSVCINFO);

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


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

    if (!QueueCmd(pHandle, "AT+CBST?\r", CMDOPT_NONE, APIID_GETBEARERSERVICEOPTIONS, ParseGetBearerServiceOptions,
                  NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}


//
//
//
HRESULT RILDrv_SetBearerServiceOptions(DWORD dwParam, const RILBEARERSVCINFO* lpBearerServiceInfo)
{
    FUNCTION_TRACE(RILDrv_SetBearerServiceOptions);
    char szCmd[MAX_PATH];
    LPSTR szWalk = szCmd;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpBearerServiceInfo)
    {
        hr = E_FAIL;
        goto Error;
    }

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

    // Add "<speed>"
    if (lpBearerServiceInfo->dwParams & RIL_PARAM_BSI_SPEED)
    {
        DEBUGCHK(RIL_SPEED_64000_MULTIMEDIA >= lpBearerServiceInfo->dwSpeed);

        if ( RIL_SPEED_UNKNOWN == lpBearerServiceInfo->dwSpeed ||
             lpBearerServiceInfo->dwSpeed > RIL_SPEED_64000_TRANSP )
        {
            hr = E_INVALIDARG;
            goto Error;
        }

        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", g_rgdwConnSpeeds[lpBearerServiceInfo->dwSpeed]);
        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 "<svc_name>"
    if (lpBearerServiceInfo->dwParams & RIL_PARAM_BSI_SERVICENAME)
    {