コード例 #1
0
ファイル: port.cpp プロジェクト: yutokt/android_vendor_intel
BOOL CPort::Open(const char* pszFileName, BOOL fIsSocket)
{
    RIL_LOG_VERBOSE("CPort::Open() - Enter  fIsSocket=[%d]\r\n", fIsSocket);
    BOOL fRet = FALSE;

    if (NULL == pszFileName)
    {
        RIL_LOG_CRITICAL("CPort::Open() - pszFileName is NULL!\r\n");
        return FALSE;
    }

    if (!m_fIsPortOpen)
    {
        if (NULL == m_pFile)
        {
            m_pFile = new CFile();
        }

        if (fIsSocket)
        {
            fRet = OpenSocket(pszFileName);
        }
        else
        {
            fRet = OpenPort(pszFileName);
        }
    }
    else
    {
        RIL_LOG_CRITICAL("CPort::Open() - Port is already open!\r\n");
    }

    RIL_LOG_VERBOSE("CPort::Open() - Exit\r\n");
    return fRet;
}
コード例 #2
0
CChannel_ATCmd::~CChannel_ATCmd()
{
    RIL_LOG_VERBOSE("CChannel_ATCmd::~CChannel_ATCmd() - Enter\r\n");
    delete[] m_paInitCmdStrings;
    RIL_LOG_VERBOSE("CChannel_ATCmd::~CChannel_ATCmd() - Exit\r\n");
    m_paInitCmdStrings = NULL;
}
コード例 #3
0
ファイル: port.cpp プロジェクト: yutokt/android_vendor_intel
BOOL CPort::Read(char* pszReadBuf, UINT32 uiReadBufSize, UINT32& ruiBytesRead)
{
    RIL_LOG_VERBOSE("CPort::Read() - Enter\r\n");
    BOOL fRet = FALSE;

    ruiBytesRead = 0;

    if (m_fIsPortOpen)
    {
        if (CFile::Read(m_pFile, pszReadBuf, uiReadBufSize, ruiBytesRead))
        {
            fRet = TRUE;
        }
        else
        {
            RIL_LOG_CRITICAL("CPort::Read() - Unable to read from port\r\n");
        }
    }
    else
    {
        CModemRestart::SaveRequestReason(3, "Port read error", "port is not open",
                CFile::GetName(m_pFile));

        RIL_LOG_CRITICAL("CPort::Read() - Port is not open!\r\n");
    }

    RIL_LOG_VERBOSE("CPort::Read() - Exit\r\n");
    return fRet;
}
コード例 #4
0
ファイル: port.cpp プロジェクト: yutokt/android_vendor_intel
BOOL CPort::Close()
{
    RIL_LOG_VERBOSE("CPort::Close() - Enter\r\n");
    BOOL fRet = FALSE;

    if (!m_fIsPortOpen)
    {
        RIL_LOG_CRITICAL("CPort::Close() - Port is already closed!\r\n");
    }
    else
    {
        m_fIsPortOpen = FALSE;
        fRet = CFile::Close(m_pFile);

        if (!fRet)
        {
            RIL_LOG_CRITICAL("CPort::Close() - Unable to properly close port!\r\n");
        }
    }

    delete m_pFile;
    m_pFile = NULL;

    RIL_LOG_VERBOSE("CPort::Close() - Exit\r\n");
    return fRet;
}
コード例 #5
0
ファイル: port.cpp プロジェクト: yutokt/android_vendor_intel
BOOL CPort::Write(const char* pszWriteBuf, const UINT32 uiBytesToWrite, UINT32& ruiBytesWritten)
{
    RIL_LOG_VERBOSE("CPort::Write() - Enter\r\n");
    BOOL fRet = FALSE;

    ruiBytesWritten = 0;

    if (m_fIsPortOpen)
    {
        if (CFile::Write(m_pFile, pszWriteBuf, uiBytesToWrite, ruiBytesWritten))
        {
            fRet = TRUE;
        }
        else
        {
            RIL_LOG_CRITICAL("CPort::Write() - Unable to write to port\r\n");
        }
    }
    else
    {
        CModemRestart::SaveRequestReason(3, "Port write error", "port is not open",
                CFile::GetName(m_pFile));

        RIL_LOG_CRITICAL("CPort::Write() - Port is not open!\r\n");
    }

    RIL_LOG_VERBOSE("CPort::Write() - Exit\r\n");
    return fRet;
}
コード例 #6
0
ファイル: port.cpp プロジェクト: yutokt/android_vendor_intel
BOOL CPort::OpenPort(const char* pszFileName)
{
    RIL_LOG_VERBOSE("CPort::OpenPort() - Enter\r\n");
    BOOL fRet = FALSE;

    if (NULL == m_pFile)
    {
        RIL_LOG_CRITICAL("CPort::OpenPort() - m_pFile is NULL");
        return fRet;
    }

    fRet = CFile::Open(m_pFile, pszFileName, FILE_ACCESS_READ_WRITE,
            FILE_OPEN_EXIST);

    if (fRet)
    {
        m_fIsPortOpen = TRUE;
    }
    else
    {
        RIL_LOG_CRITICAL("CPort::OpenPort()  CANNOT OPEN PORT\r\n");
    }

    RIL_LOG_VERBOSE("CPort::OpenPort() - Exit\r\n");
    return fRet;
}
コード例 #7
0
CChannel_DLC2::~CChannel_DLC2()
{
    RIL_LOG_VERBOSE("CChannel_DLC2::~CChannel_DLC2() - Enter\r\n");
    delete[] m_paInitCmdStrings;
    m_paInitCmdStrings = NULL;
    RIL_LOG_VERBOSE("CChannel_DLC2::~CChannel_DLC2() - Exit\r\n");
}
コード例 #8
0
BOOL CChannel_ATCmd::FinishInit()
{
    RIL_LOG_VERBOSE("CChannel_ATCmd::FinishInit() - Enter\r\n");
    BOOL bRet = FALSE;

    // Init our channel AT init commands.
    m_paInitCmdStrings = new INITSTRING_DATA[COM_MAX_INDEX];
    if (!m_paInitCmdStrings)
    {
        RIL_LOG_CRITICAL("CChannel_ATCmd::FinishInit() : chnl=[%d] Could not create new "
                "INITSTRING_DATA\r\n", m_uiRilChannel);
        goto Error;
    }

    // Set the init command strings for this channel
    m_paInitCmdStrings[COM_BASIC_INIT_INDEX].szCmd = m_szChannelBasicInitCmd;
    m_paInitCmdStrings[COM_UNLOCK_INIT_INDEX].szCmd = m_szChannelUnlockInitCmd;

    m_paInitCmdStrings[COM_POWER_ON_INIT_INDEX] = ATCmdPowerOnInitString;
    m_paInitCmdStrings[COM_READY_INIT_INDEX] = ATCmdReadyInitString;

    bRet = TRUE;
Error:
    RIL_LOG_VERBOSE("CChannel_ATCmd::FinishInit() - Exit\r\n");
    return bRet;
}
コード例 #9
0
//
// RIL_REQUEST_SIM_TRANSMIT_CHANNEL
//
RIL_RESULT_CODE CTE_XMM2230::CoreSimTransmitChannel(REQUEST_DATA& /*rReqData*/,
                                                           void* /*pData*/,
                                                           UINT32 /*uiDataSize*/)
{
    RIL_LOG_VERBOSE("CTE_XMM2230::CoreSimTransmitChannel() - Enter\r\n");
    RIL_RESULT_CODE res = RRIL_RESULT_NOTSUPPORTED;

    RIL_LOG_VERBOSE("CTE_XMM2230::CoreSimTransmitChannel() - Exit\r\n");
    return res;
}
コード例 #10
0
ファイル: port.cpp プロジェクト: yutokt/android_vendor_intel
BOOL CPort::OpenSocket(const char* pszSocketName)
{
    RIL_LOG_VERBOSE("CPort::OpenSocket() - Enter\r\n");

    // TODO : Pull this from repository
    const char szSocketInit[] = "gsm";

    UINT32 uiBytesWritten = 0;
    UINT32 uiBytesRead = 0;
    char szResponse[10] = {0};

    BOOL fRet = FALSE;

    const UINT32 uiRetries = 30;
    const UINT32 uiInterval = 2000;

    for (UINT32 uiAttempts = 0; uiAttempts < uiRetries; uiAttempts++)
    {
        fRet = CFile::Open(m_pFile, pszSocketName, 0, 0, TRUE);

        if (fRet)
        {
            m_fIsPortOpen = TRUE;
            RIL_LOG_INFO("CPort::OpenSocket() - Port is open!!\r\n");
            break;
        }

        Sleep(uiInterval);
    }

    if (fRet)
    {
        if (Write(szSocketInit, strlen(szSocketInit), uiBytesWritten))
        {
            if (Read(szResponse, sizeof(szResponse), uiBytesRead))
            {
                m_fIsPortOpen = TRUE;
            }
            else
            {
                RIL_LOG_CRITICAL("CPort::OpenSocket() - Unable to read response from socket\r\n");
                fRet = FALSE;
            }
        }
        else
        {
            RIL_LOG_CRITICAL("CPort::OpenSocket() - Unable to write \"%s\" to socket\r\n",
                    szSocketInit);
            fRet = FALSE;
        }
    }

    RIL_LOG_VERBOSE("CPort::OpenSocket() - Exit\r\n");
    return fRet;
}
コード例 #11
0
INT32 CellInfoCache::checkCache(const RIL_CellInfo& pData)
{
    RIL_LOG_VERBOSE("CellInfoCache::checkCache() %d\r\n", m_iCacheSize);
    for (INT32 i = 0; i < m_iCacheSize; i++)
    {
        if (pData == m_sCellInfo.pnCellData[i])
        {
            RIL_LOG_VERBOSE("CellInfoCache::checkCache() - Found match at %d\r\n",i);
            return i;
        }
    }
    return -1;
}
コード例 #12
0
char* CTE_XMM2230::GetUnlockInitCommands(UINT32 uiChannelType)
{
    RIL_LOG_VERBOSE("CTE_XMM2230::GetUnlockInitCommands() - Enter\r\n");

    char szInitCmd[MAX_BUFFER_SIZE] = {'\0'};

    if (RIL_CHANNEL_URC == uiChannelType)
    {
        ConcatenateStringNullTerminate(szInitCmd, sizeof(szInitCmd), "|+CGAUTO=0|+CRC=1");
    }

    RIL_LOG_VERBOSE("CTE_XMM2230::GetUnlockInitCommands() - Exit\r\n");
    return strndup(szInitCmd, strlen(szInitCmd));
}
コード例 #13
0
//
// IMS network support reporting
//
BOOL CSilo_IMS::ParseCIREPI(CResponse* const pResponse, const char*& rszPointer)
{
    RIL_LOG_VERBOSE("CSilo_IMS::ParseCIREPI() - Enter\r\n");

    BOOL   fRet = FALSE;
    UINT32 uiNwimsvops = 0;
    char   szAlpha[MAX_BUFFER_SIZE];
    int pos = 0;
    sOEM_HOOK_RAW_UNSOL_IMS_SUPPORT_STATUS data;

    if (NULL == pResponse)
    {
        RIL_LOG_CRITICAL("CSilo_IMS::ParseCIREPI() - pResponse is NULL.\r\n");
        goto Error;
    }

    pResponse->SetUnsolicitedFlag(TRUE);

    // Throw out the alpha chars if there are any
    (void)ExtractQuotedString(rszPointer, szAlpha, MAX_BUFFER_SIZE, rszPointer);

    // Parse "<nwimsvops>"
    if (!ExtractUInt32(rszPointer, uiNwimsvops, rszPointer))
    {
        RIL_LOG_CRITICAL("CSilo_IMS::ParseCIREPI() - Could not parse IMS Voice over PS"
                "support indication\r\n");
        goto Error;
    }

    data.command = RIL_OEM_HOOK_RAW_UNSOL_IMS_SUPPORT_STATUS;
    data.status = uiNwimsvops;

    // Framework will trigger IMS registration depending on this information.
    RIL_LOG_INFO("CSilo_IMS::ParseCIREPI() - CIREPI=[%d]\r\n", uiNwimsvops);

    pResponse->SetResultCode(RIL_UNSOL_OEM_HOOK_RAW);

    if (!pResponse->SetData((void*)&data,
            sizeof(sOEM_HOOK_RAW_UNSOL_IMS_SUPPORT_STATUS), TRUE))
    {
        goto Error;
    }

    fRet = TRUE;
Error:
    RIL_LOG_VERBOSE("CSilo_IMS::ParseCIREPI() - Exit\r\n");
    return fRet;
}
コード例 #14
0
//
// RIL_REQUEST_BASEBAND_VERSION
//
RIL_RESULT_CODE CTE_XMM2230::CoreBasebandVersion(REQUEST_DATA& rReqData,
        void* pData, UINT32 uiDataSize)
{
    RIL_LOG_VERBOSE("CTE_XMM2230::CoreBasebandVersion() - Enter\r\n");

    RIL_RESULT_CODE res = RRIL_RESULT_ERROR;

    if (CopyStringNullTerminate(rReqData.szCmd1, "at+xgendata\r",
            sizeof(rReqData.szCmd1)))
    {
        res = RRIL_RESULT_OK;
    }

    RIL_LOG_VERBOSE("CTE_XMM2230::CoreBasebandVersion() - Exit\r\n");
    return res;
}
コード例 #15
0
CSilo_rfcoexistence::CSilo_rfcoexistence(CChannel* pChannel)
: CSilo(pChannel)
{
    RIL_LOG_VERBOSE("CSilo_rfcoexistence::CSilo_rfcoexistence() - Enter\r\n");

    // AT Response Table
    static ATRSPTABLE pATRspTable[] =
    {
        { "+XMETRIC: "  , (PFN_ATRSP_PARSE)&CSilo_rfcoexistence::ParseXMETRIC },
        { "+XNRTCWSI: " , (PFN_ATRSP_PARSE)&CSilo_rfcoexistence::ParseXNRTCWSI },
        { ""           , (PFN_ATRSP_PARSE)&CSilo_rfcoexistence::ParseNULL }
    };

    m_pATRspTable = pATRspTable;
    RIL_LOG_VERBOSE("CSilo_rfcoexistence::CSilo_rfcoexistence() - Exit\r\n");
}
コード例 #16
0
void triggerQueryDefaultPDNContextParams(void* param)
{
    REQUEST_DATA rReqData;
    memset(&rReqData, 0, sizeof(REQUEST_DATA));
    CChannel_Data* pChannelData = NULL;
    UINT32 uiCID = 0;

    if (param == NULL)
        return;

    pChannelData = (CChannel_Data*)param;

    uiCID = pChannelData->GetContextID();

    RIL_LOG_VERBOSE("triggerQueryDefaultPDNContextParams - uiCID: %u\r\n", uiCID);

    if (PrintStringNullTerminate(rReqData.szCmd1, sizeof(rReqData.szCmd1), "AT+CGCONTRDP=%u\r",
            uiCID))
    {
        CCommand* pCmd = new CCommand(pChannelData->GetRilChannel(), NULL, REQ_ID_NONE,
                rReqData, &CTE::ParseReadContextParams,
                &CTE::PostReadDefaultPDNContextParams);
        if (pCmd)
        {
            if (!CCommand::AddCmdToQueue(pCmd))
            {
                RIL_LOG_CRITICAL("triggerQueryDefaultPDNContextParams - "
                        "Unable to queue AT+CGCONTRDP command!\r\n");
                delete pCmd;
            }
        }
    }
}
コード例 #17
0
int MapErrorCodeToRilDataFailCause(UINT32 uiCause)
{
    RIL_LOG_VERBOSE("MapErrorCodeToRilDataFailCause() - Enter\r\n");

    switch (uiCause)
    {
        case CEER_CAUSE_OPERATOR_DETERMINED_BARRING:
            return PDP_FAIL_OPERATOR_BARRED;
        case CEER_CAUSE_INSUFFICIENT_RESOURCES:
            return PDP_FAIL_INSUFFICIENT_RESOURCES;
        case CEER_CAUSE_MISSING_UNKNOWN_APN:
            return PDP_FAIL_MISSING_UKNOWN_APN;
        case CEER_CAUSE_UNKNOWN_PDP_ADDRESS_TYPE:
            return PDP_FAIL_UNKNOWN_PDP_ADDRESS_TYPE;
        case CEER_CAUSE_USER_AUTHENTICATION_FAILED:
            return PDP_FAIL_USER_AUTHENTICATION;
        case CEER_CAUSE_ACTIVATION_REJECTED_BY_GGSN:
            return PDP_FAIL_ACTIVATION_REJECT_GGSN;
        case CEER_CAUSE_ACTIVATION_REJECT_UNSPECIFIED:
            return PDP_FAIL_ACTIVATION_REJECT_UNSPECIFIED;
        case CEER_CAUSE_OPTION_NOT_SUPPORTED:
            return PDP_FAIL_SERVICE_OPTION_NOT_SUPPORTED;
        case CEER_CAUSE_OPTION_NOT_SUBSCRIBED:
            return PDP_FAIL_SERVICE_OPTION_NOT_SUBSCRIBED;
        case CEER_CAUSE_OPTION_TEMP_OUT_OF_ORDER:
            return PDP_FAIL_SERVICE_OPTION_OUT_OF_ORDER;
        case CEER_CAUSE_NSPAI_ALREADY_USED:
            return PDP_FAIL_NSAPI_IN_USE;
        case CEER_CAUSE_PDP_AUTHENTICATION_FAILURE:
            return PDP_FAIL_USER_AUTHENTICATION;
        default:
            return PDP_FAIL_ERROR_UNSPECIFIED;
    }
}
コード例 #18
0
// CContextEvent
void CContextEvent::Execute(BOOL bRes, UINT32 /*uiErrorCode*/)
{
    if (bRes)
    {
        RIL_LOG_VERBOSE("CContextEvent::Execute() - Signalling event!\r\n");
        CEvent::Signal(&m_pEvent);
    }
}
コード例 #19
0
//
// IMS-SRVCC sync notification
//
BOOL CSilo_IMS::ParseXISRVCCI(CResponse* const pResponse, const char*& rszPointer)
{
    RIL_LOG_VERBOSE("CSilo_IMS::ParseXISRVCCI() - Enter\r\n");

    BOOL   fRet     = FALSE;
    UINT32 uiSrvccHoStatus = 0;
    char   szAlpha[MAX_BUFFER_SIZE];
    sOEM_HOOK_RAW_UNSOL_IMS_SRVCC_HO_STATUS data;

    if (NULL == pResponse)
    {
        RIL_LOG_CRITICAL("CSilo_IMS::ParseXISRVCCI() - pResponse is NULL.\r\n");
        goto Error;
    }

    pResponse->SetUnsolicitedFlag(TRUE);

    // Throw out the alpha chars if there are any
    (void)ExtractQuotedString(rszPointer, szAlpha, MAX_BUFFER_SIZE, rszPointer);

    // Parse "<srvcc_ho_status>"
    if (!ExtractUInt32(rszPointer, uiSrvccHoStatus, rszPointer))
    {
        RIL_LOG_CRITICAL("CSilo_IMS::ParseXISRVCCI() - Could not parse SRVCC HO"
                "status indication\r\n");
        goto Error;
    }

    data.command = RIL_OEM_HOOK_RAW_UNSOL_IMS_SRVCC_HO_STATUS;
    data.status = uiSrvccHoStatus;

    RIL_LOG_VERBOSE("CSilo_IMS::ParseXISRVCCI() - XISRVCC=[%u]\r\n", uiSrvccHoStatus);

    pResponse->SetResultCode(RIL_UNSOL_OEM_HOOK_RAW);

    if (!pResponse->SetData((void*)&data,
            sizeof(sOEM_HOOK_RAW_UNSOL_IMS_SRVCC_HO_STATUS), TRUE))
    {
        goto Error;
    }

    fRet = TRUE;
Error:
    RIL_LOG_VERBOSE("CSilo_IMS::ParseXISRVCCI() - Exit\r\n");
    return fRet;
}
コード例 #20
0
CSilo_MISC::CSilo_MISC(CChannel* pChannel, CSystemCapabilities* pSysCaps)
: CSilo(pChannel, pSysCaps)
{
    RIL_LOG_VERBOSE("CSilo_MISC::CSilo_MISC() - Enter\r\n");

    // AT Response Table
    static ATRSPTABLE pATRspTable[] =
    {
        { "+XDRVI: "   , (PFN_ATRSP_PARSE)&CSilo_MISC::ParseXDRVI  },
        { "+XMETRIC: "  , (PFN_ATRSP_PARSE)&CSilo_MISC::ParseXMETRIC },
        { "+XNRTCWSI: " , (PFN_ATRSP_PARSE)&CSilo_MISC::ParseXNRTCWSI },
        { ""           , (PFN_ATRSP_PARSE)&CSilo_MISC::ParseNULL }
    };

    m_pATRspTable = pATRspTable;
    RIL_LOG_VERBOSE("CSilo_MISC::CSilo_MISC() - Exit\r\n");
}
コード例 #21
0
CSilo_Data::CSilo_Data(CChannel* pChannel)
: CSilo(pChannel)
{
    RIL_LOG_VERBOSE("CSilo_Data::CSilo_Data() - Enter\r\n");

    // AT Response Table
    static ATRSPTABLE pATRspTable[] =
    {
        { "NO CARRIER"  , (PFN_ATRSP_PARSE)&CSilo_Data::ParseNoCarrier },
        { "+XCIEV: "      , (PFN_ATRSP_PARSE)&CSilo_Data::ParseUnrecognized },
        { "+XCIEV:"      , (PFN_ATRSP_PARSE)&CSilo_Data::ParseUnrecognized },
        { ""         , (PFN_ATRSP_PARSE)&CSilo_Data::ParseNULL         }
    };

    m_pATRspTable = pATRspTable;

    RIL_LOG_VERBOSE("CSilo_Data::CSilo_Data() - Exit\r\n");
}
コード例 #22
0
ファイル: port.cpp プロジェクト: yutokt/android_vendor_intel
BOOL CPort::WaitForAvailableData(UINT32 uiTimeout)
{
    RIL_LOG_VERBOSE("CPort::WaitForAvailableData() - Enter\r\n");
    BOOL fRet = FALSE;
    UINT32 uiMask = 0;

    if (m_fIsPortOpen)
    {
        fRet = CFile::WaitForEvent(m_pFile, uiMask, uiTimeout);

        if(fRet)
        {
            if (uiMask & FILE_EVENT_ERROR)
            {
                RIL_LOG_CRITICAL("CPort::WaitForAvailableData() - FILE_EVENT_ERROR received"
                        " on port\r\n");
            }

            if (uiMask & FILE_EVENT_BREAK)
            {
                RIL_LOG_INFO("CPort::WaitForAvailableData() - FILE_EVENT_BREAK received on"
                        " port\r\n");
            }

            if (uiMask & FILE_EVENT_RXCHAR)
            {
                fRet = TRUE;
            }
        }
        else
        {
            RIL_LOG_CRITICAL("CPort::WaitForAvailableData() - Returning failure\r\n");
        }
    }
    else
    {
        CModemRestart::SaveRequestReason(3, "Port is not open", "", CFile::GetName(m_pFile));
        RIL_LOG_CRITICAL("CPort::WaitForAvailableData() - Port is not open!\r\n");
    }

Error:
    RIL_LOG_VERBOSE("CPort::WaitForAvailableData() - Exit\r\n");
    return fRet;
}
コード例 #23
0
void triggerQueryBearerParams(void* param)
{
    REQUEST_DATA rReqDataTFT;
    REQUEST_DATA rReqDataQOS;
    memset(&rReqDataTFT, 0, sizeof(REQUEST_DATA));
    memset(&rReqDataQOS, 0, sizeof(REQUEST_DATA));
    CChannel_Data* pChannelData = NULL;
    UINT32 uiPCID = 0;
    UINT32 uiCID = 0;
    void** callbackParams = NULL;

    if (param == NULL)
        return;

    callbackParams = (void**)param;
    uiPCID = (UINT32)callbackParams[0];
    uiCID = (UINT32)callbackParams[1];
    pChannelData = (CChannel_Data*)callbackParams[2];

    delete callbackParams;

    RIL_LOG_VERBOSE("triggerQueryBearerParams - uiPCID: %u, uiCID: %u\r\n", uiPCID, uiCID);

    if (PrintStringNullTerminate(rReqDataTFT.szCmd1, sizeof(rReqDataTFT.szCmd1), "AT+CGTFTRDP=%u\r",
            uiCID))
    {
        CCommand* pCmdTFT = new CCommand(pChannelData->GetRilChannel(), NULL, REQ_ID_NONE,
                rReqDataTFT, &CTE::ParseReadBearerTFTParams);
        if (pCmdTFT)
        {
            if (!CCommand::AddCmdToQueue(pCmdTFT))
            {
                RIL_LOG_CRITICAL("triggerQueryBearerParams - "
                        "Unable to queue AT+CGTFTRDP command!\r\n");
                delete pCmdTFT;
            }
        }
    }

    if (PrintStringNullTerminate(rReqDataQOS.szCmd1, sizeof(rReqDataQOS.szCmd1), "AT+CGEQOS=%u\r",
            uiCID))
    {
        CCommand* pCmdQOS = new CCommand(pChannelData->GetRilChannel(), NULL, REQ_ID_NONE,
                rReqDataQOS, &CTE::ParseReadBearerQOSParams);
        if (pCmdQOS)
        {
            if (!CCommand::AddCmdToQueue(pCmdQOS))
            {
                RIL_LOG_CRITICAL("triggerQueryBearerParams - "
                        "Unable to queue AT+CGEQOS command!\r\n");
                delete pCmdQOS;
            }
        }
    }
}
コード例 #24
0
CInitializer* CTE_XMM2230::GetInitializer()
{
    RIL_LOG_VERBOSE("CTE_XMM2230::GetInitializer() - Enter\r\n");
    CInitializer* pRet = NULL;

    RIL_LOG_INFO("CTE_XMM2230::GetInitializer() - Creating CInit2230 initializer\r\n");
    m_pInitializer = new CInit2230();
    if (NULL == m_pInitializer)
    {
        RIL_LOG_CRITICAL("CTE_XMM2230::GetInitializer() - Failed to create a CInit2230 "
                "initializer!\r\n");
        goto Error;
    }

    pRet = m_pInitializer;

Error:
    RIL_LOG_VERBOSE("CTE_XMM2230::GetInitializer() - Exit\r\n");
    return pRet;
}
コード例 #25
0
CSilo_IMS::CSilo_IMS(CChannel* pChannel)
: CSilo(pChannel)
{
    RIL_LOG_VERBOSE("CSilo_IMS::CSilo_IMS() - Enter\r\n");

    // AT Response Table
    static ATRSPTABLE pATRspTable[] =
    {
        { "+CIREPI: "        , (PFN_ATRSP_PARSE)&CSilo_IMS::ParseCIREPI  },
        { "+CIREPH: "        , (PFN_ATRSP_PARSE)&CSilo_IMS::ParseCIREPH  },
        { "+CIREGU: "        , (PFN_ATRSP_PARSE)&CSilo_IMS::ParseCIREGU },
        { "+XISRVCCI: "       , (PFN_ATRSP_PARSE)&CSilo_IMS::ParseXISRVCCI },
        { "+XISRVCCSTATI: "  , (PFN_ATRSP_PARSE)&CSilo_IMS::ParseUnrecognized },
        // FIXME: Following strings to be confirmed and parsed.
        { "+IMSCALLSTAT: "   , (PFN_ATRSP_PARSE)&CSilo_IMS::ParseNULL },
        { "+IMSSMSSTAT: "    , (PFN_ATRSP_PARSE)&CSilo_IMS::ParseNULL },
        { ""                 , (PFN_ATRSP_PARSE)&CSilo_IMS::ParseNULL }
    };

    m_pATRspTable = pATRspTable;

    RIL_LOG_VERBOSE("CSilo_IMS::CSilo_IMS() - Exit\r\n");
}
コード例 #26
0
BOOL CellInfoCache::updateCache(const P_ND_N_CELL_INFO_DATA pData, const INT32 aItemsCount)
{
    BOOL ret = FALSE;

    RIL_LOG_VERBOSE("CellInfoCache::updateCache() - aItemsCount %d \r\n",aItemsCount);
    if (NULL == pData || aItemsCount > RRIL_MAX_CELL_ID_COUNT)
    {
        RIL_LOG_INFO("CellInfoCache::updateCache() - Invalid data\r\n");
        goto Error;
    }
    else
    {
        // if there were more items in the cache before
        if (aItemsCount != m_iCacheSize)
        {
            ret = TRUE;
        }
        else
        {
            for (INT32 storeIndex= 0; storeIndex < aItemsCount; storeIndex++)
            {
                if (checkCache(pData->pnCellData[storeIndex]) < 0 ) // new item
                {
                    ret = TRUE;
                    break;
                }
            }
        }
    }

    if (ret)
    {
        RIL_LOG_INFO("CellInfoCache::updateCache() -"
                "Updating cache with %d items\r\n", aItemsCount);
        // Access mutex
        CMutex::Lock(m_pCacheLock);
        m_iCacheSize = aItemsCount;
        memset(&m_sCellInfo, 0, sizeof(S_ND_N_CELL_INFO_DATA));
        for (INT32 j = 0; j < m_iCacheSize; j++)
        {
            m_sCellInfo.pnCellData[j] = pData->pnCellData[j];
        }
        // release mutex
        CMutex::Unlock(m_pCacheLock);
    }
Error:
    return ret;
}
コード例 #27
0
CSilo_MISC::~CSilo_MISC()
{
    RIL_LOG_VERBOSE("CSilo_MISC::~CSilo_MISC() - Enter\r\n");
    RIL_LOG_VERBOSE("CSilo_MISC::~CSilo_MISC() - Exit\r\n");
}
コード例 #28
0
//
// Thermal sensor notification
//
BOOL CSilo_MISC::ParseXDRVI(CResponse* const pResponse, const char*& rszPointer)
{
    RIL_LOG_VERBOSE("CSilo_MISC::ParseXDRVI() - Enter\r\n");
    BOOL   fRet = FALSE;
    sOEM_HOOK_RAW_UNSOL_THERMAL_ALARM_IND* pData = NULL;
    UINT32 nIpcChrGrp;
    UINT32 nIpcChrTempThresholdInd;
    UINT32 nXdrvResult;
    UINT32 nSensorId;
    UINT32 nTemp;

    if (NULL == pResponse)
    {
        RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() - pResponse is NULL.\r\n");
        goto Error;
    }

    pResponse->SetUnsolicitedFlag(TRUE);

    // Extract "<IPC_CHR_GRP>"
    if (!ExtractUInt32(rszPointer, nIpcChrGrp, rszPointer))
    {
        RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() - Could not parse nIpcChrGrp.\r\n");
        goto Error;
    }

    // Parse <IPC_CHR_TEMP_THRESHOLD_IND>
    if (!SkipString(rszPointer, ",", rszPointer) ||
        !ExtractUInt32(rszPointer, nIpcChrTempThresholdInd, rszPointer))
    {
         RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() -"
                 " Unable to parse <IPC_CHR_TEMP_THRESHOLD_IND>!\r\n");
         goto Error;
    }

    // Parse <xdrv_result>
    if (!SkipString(rszPointer, ",", rszPointer) ||
        !ExtractUInt32(rszPointer, nXdrvResult, rszPointer))
    {
         RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() - Unable to parse <xdrv_result>!\r\n");
         goto Error;
    }

    // Parse <temp_sensor_id>
    if (!SkipString(rszPointer, ",", rszPointer) ||
        !ExtractUInt32(rszPointer, nSensorId, rszPointer))
    {
         RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() - Unable to parse <temp_sensor_id>!\r\n");
         goto Error;
    }

    // Parse <temp>
    if (!SkipString(rszPointer, ",", rszPointer) ||
        !ExtractUInt32(rszPointer, nTemp, rszPointer))
    {
         RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() - Unable to parse <temp>!\r\n");
         goto Error;
    }

    RIL_LOG_INFO("CSilo_MISC::ParseXDRVI - IPC_CHR_GRP: %u, IPC_CHR_TEMP_THRESHOLD_IND: %u,"
            " xdrv_result: %u\r\n", nIpcChrGrp, nIpcChrTempThresholdInd, nXdrvResult);
    RIL_LOG_INFO("CSilo_MISC::ParseXDRVI - temp_sensor_id: %u, temp: %u\r\n", nSensorId, nTemp);

    pData = (sOEM_HOOK_RAW_UNSOL_THERMAL_ALARM_IND*)malloc(
            sizeof(sOEM_HOOK_RAW_UNSOL_THERMAL_ALARM_IND));
    if (NULL == pData)
    {
        RIL_LOG_CRITICAL("CSilo_MISC::ParseXDRVI() - Could not allocate memory for pData.\r\n");
        goto Error;
    }
    memset(pData, 0, sizeof(sOEM_HOOK_RAW_UNSOL_THERMAL_ALARM_IND));

    pData->nCommand = RIL_OEM_HOOK_RAW_UNSOL_THERMAL_ALARM_IND;
    pData->nSensorId = nSensorId;
    pData->nTemp = nTemp;

    pResponse->SetResultCode(RIL_UNSOL_OEM_HOOK_RAW);

    if (!pResponse->SetData((void*)pData, sizeof(sOEM_HOOK_RAW_UNSOL_THERMAL_ALARM_IND), FALSE))
    {
        goto Error;
    }

    fRet = TRUE;
Error:
    if (!fRet)
    {
        free(pData);
        pData = NULL;
    }

    RIL_LOG_VERBOSE("CSilo_MISC::ParseXDRVI() - Exit\r\n");
    return fRet;
}
コード例 #29
0
CChannel_ATCmd::CChannel_ATCmd(UINT32 uiChannel)
: CChannel(uiChannel)
{
    RIL_LOG_VERBOSE("CChannel_ATCmd::CChannel_ATCmd() - Enter\r\n");
    RIL_LOG_VERBOSE("CChannel_ATCmd::CChannel_ATCmd() - Exit\r\n");
}
コード例 #30
0
ファイル: port.cpp プロジェクト: yutokt/android_vendor_intel
BOOL CPort::Init()
{
    RIL_LOG_VERBOSE("CPort::Init() - Enter\r\n");
    BOOL fRet = FALSE;

    int fd = 0;
    int bit = 0;
    int flag;
    struct termios oldtio;
    struct termios newtio;

    if (m_fIsPortOpen)
    {
        fd = CFile::GetFD(m_pFile);

        if (fd >= 0)
        {
            // save current port settings
            tcgetattr(fd,&oldtio);

            // switch TTY to NON BLOCKING mode for Rd/Wr RRIL operations
            flag = fcntl(fd, F_GETFL, 0);
            flag |= O_NONBLOCK;

            if (fcntl(fd, F_SETFL, flag) < 0)
                perror("fcntl()");

            bzero(&newtio, sizeof(newtio));
            newtio.c_cflag = B115200;

            newtio.c_cflag |= CS8 | CLOCAL | CREAD;
            newtio.c_iflag &= ~(INPCK | IGNPAR | PARMRK | ISTRIP | IXANY | ICRNL);
            newtio.c_oflag &= ~OPOST;
            newtio.c_cc[VMIN]  = 1;
            newtio.c_cc[VTIME] = 10;

            // set input mode (non-canonical, no echo,...)
            newtio.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
            //newtio.c_lflag &= ~(ICANON | ISIG);

            //newtio.c_cc[VTIME]    = 1000;   /* inter-character timer unused */
            //newtio.c_cc[VMIN]     = 1;   /* blocking read until 5 chars received */

            tcflush(fd, TCIFLUSH);
            tcsetattr(fd,TCSANOW,&newtio);

            bit = TIOCM_DTR;
            /*
            if(ioctl(fd, TIOCMBIS, &bit))
            {
                RIL_LOG_CRITICAL("CPort::Init() - ioctl(%d, 0x%x, 0x%x) failed with error="
                        " %d\r\n", errno);
            }
            else
            {
                fRet = TRUE;
            }
            */
            fRet = TRUE;
        }
        else
        {
            RIL_LOG_CRITICAL("CPort::Init() - File descriptor was negative!\r\n");
        }
    }
    else
    {
        RIL_LOG_CRITICAL("CPort::Init() - Port is not open!\r\n");
    }

    RIL_LOG_VERBOSE("CPort::Init() - Exit\r\n");
    return fRet;
}