data.cpp

ril source code for Windows CE

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this sample source code is subject to the terms of the Microsoft
// license agreement under which you licensed this sample source code. If
// you did not accept the terms of the license agreement, you are not
// authorized to use this sample source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the LICENSE.RTF on your install media or the root of your tools installation.
// THE SAMPLE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES.
//
/*++
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.

Module Name:

data.cpp

Abstract:


Notes:


--*/


#include "precomp.h"

//
// Connection speeds
//
const DWORD g_rgdwConnSpeeds[] =
{
    0xFFFFFFFF,     // RIL_SPEED_UNKNOWN
    0,      // RIL_SPEED_AUTO
    1,      // RIL_SPEED_300_V21
    65,     // RIL_SPEED_300_V110
    2,      // RIL_SPEED_1200_V22
    3,      // RIL_SPEED_1200_75_V23
    66,     // RIL_SPEED_1200_V110
    34,     // RIL_SPEED_1200_V120
    4,      // RIL_SPEED_2400_V22BIS
    5,      // RIL_SPEED_2400_V26TER
    68,     // RIL_SPEED_2400_V110
    36,     // RIL_SPEED_2400_V120
    6,      // RIL_SPEED_4800_V32
    70,     // RIL_SPEED_4800_V110
    38,     // RIL_SPEED_4800_V120
    7,      // RIL_SPEED_9600_V32
    12,     // RIL_SPEED_9600_V34
    71,     // RIL_SPEED_9600_V110
    39,     // RIL_SPEED_9600_V120
    14,     // RIL_SPEED_14400_V34
    75,     // RIL_SPEED_14400_V110
    43,     // RIL_SPEED_14400_V120
    15,     // RIL_SPEED_19200_V34
    79,     // RIL_SPEED_19200_V110
    47,     // RIL_SPEED_19200_V120
    16,     // RIL_SPEED_28800_V34
    80,     // RIL_SPEED_28800_V110
    48,     // RIL_SPEED_28800_V120
    81,     // RIL_SPEED_38400_V110
    49,     // RIL_SPEED_38400_V120
    82,     // RIL_SPEED_48000_V110
    50,     // RIL_SPEED_48000_V120
    83,     // RIL_SPEED_56000_V110
    51,     // RIL_SPEED_56000_V120
    115,    // RIL_SPEED_56000_TRANSP
    116,    // RIL_SPEED_64000_TRANSP
    120,    // RIL_SPEED_32000_PIAFS32K
    121,    // RIL_SPEED_64000_PIAFS64K
    130,    // RIL_SPEED_28800_MULTIMEDIA
    131,    // RIL_SPEED_32000_MULTIMEDIA
    132,    // RIL_SPEED_33600_MULTIMEDIA
    133,    // RIL_SPEED_56000_MULTIMEDIA
    134,    // RIL_SPEED_64000_MULTIMEDIA
};
const size_t ConnSpeedsEcount = sizeof(g_rgdwConnSpeeds) / sizeof(*g_rgdwConnSpeeds);

//
// HSCSD channel codings
//
const DWORD g_rgdwHSCSDCodings[] =
{
    RIL_HSCSDCODING_4800_FULLRATE,      // 1 = 2^0
    0,                                  // 2 = 2^1
    RIL_HSCSDCODING_9600_FULLRATE,      // 4 = 2^2
    RIL_HSCSDCODING_14400_FULLRATE,     // 8 = 2^3
};
const size_t HscsdCodingsEcount = sizeof(g_rgdwHSCSDCodings) / sizeof(*g_rgdwHSCSDCodings);

const DWORD g_rgdwHSCSDAirRates[] =
{
    0,      // RIL_HSCSDAIURATE_UNKNOWN
    1,      // RIL_HSCSDAIURATE_9600
    2,      // RIL_HSCSDAIURATE_14400
    3,      // RIL_HSCSDAIURATE_19200
    4,      // RIL_HSCSDAIURATE_28800
    5,      // RIL_HSCSDAIURATE_38400
    6,      // RIL_HSCSDAIURATE_43200
    7,      // RIL_HSCSDAIURATE_57600
};
const size_t HscsdAirRatesEcount = sizeof(g_rgdwHSCSDAirRates) / sizeof(*g_rgdwHSCSDAirRates);

//
// Bearer service names
//
static const DWORD g_rgdwBearerSvcNames[] =
{
    0xFFFFFFFF,     // 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[] =
{
    0xFFFFFFFF,     // 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))

//
//
//
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) ||
        !ParseUInt(szRsp, TRUE, 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) ||
        !ParseUIntAndVerifyAbove(szRsp, TRUE, 8, 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) ||
        !ParseUInt(szRsp, TRUE, 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);

    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:

    return hr;
}


//
//
//
HRESULT RILDrv_SetHSCSDOptions(DWORD dwParam, const RILHSCSDINFO* lpHscsdInfo)
{
    FUNCTION_TRACE(RILDrv_SetHSCSDOptions);

    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);
                }