comhand.cpp

手机RILGSM实现的源代码

    fRet = TRUE;

    Error:
    return fRet;
}


//
// Serial read
//
BOOL CComHandle::Read(void* pBuf, const UINT cb, DWORD& rdwRead) const
{
    // FUNCTION_TRACE(CComHandle::Read);
    DWORD dwDownstreamRead;
    BOOL fRet = FALSE;

    rdwRead = 0;

    if (!m_fInited || !m_fPortOpened || INVALID_HANDLE_VALUE == m_hDownstream)
    {
        goto Error;
    }

    if (cb > 0)
    {
        if (!DOWNST_READFILE(m_hDownstream, pBuf, cb, &dwDownstreamRead))
        {
            goto Error;
        }
        if (dwDownstreamRead)
        {
#ifdef DEBUG
            DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : t : CComHandle::Read : Read bytes(1): %s\r\n"),
                       TString(PrintableString((char*)pBuf, dwDownstreamRead))));
#endif // DEBUG
        }
        rdwRead = dwDownstreamRead;
    }
    fRet = TRUE;

    Error:
    return fRet;
}

#ifdef OEM2_DRIVER
//
// Serial read from Second (notification) port
//
BOOL CComHandle::Read2(void* pBuf, const UINT cb, DWORD& rdwRead) const
{
    // FUNCTION_TRACE(CComHandle::Read2);
    DWORD dwDownstreamRead;
    BOOL fRet = FALSE;

    rdwRead = 0;

    if (!m_fInited || !m_fPortOpened || INVALID_HANDLE_VALUE == m_hDownstream2)
    {
        goto Error;
    }

    if (cb > 0)
    {
        if (!DOWNST_READFILE(m_hDownstream2, pBuf, cb, &dwDownstreamRead))
        {
            goto Error;
        }
        if (dwDownstreamRead)
        {
#ifdef DEBUG
            DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : t : CComHandle::Read2 : Read bytes(1): %s\r\n"),
                       TString(PrintableString((char*)pBuf, dwDownstreamRead))));
#endif // DEBUG
        }
        rdwRead = dwDownstreamRead;
    }
    fRet = TRUE;

    Error:
    return fRet;
}
#endif


//
// Serial write
//
BOOL CComHandle::Write(const void* pBuf, const UINT cb, DWORD& rdwWritten) const
{
    // FUNCTION_TRACE(CComHandle::Write);
    DWORD fRet = FALSE;
    DWORD dwDownstreamWritten;

    rdwWritten = 0;

    if (!m_fInited || !m_fPortOpened || INVALID_HANDLE_VALUE == m_hDownstream)
    {
        goto Error;
    }

    if (cb > 0)
    {
        if (!DOWNST_WRITEFILE(m_hDownstream, pBuf, cb, &dwDownstreamWritten))
        {
            goto Error;
        }
        rdwWritten = dwDownstreamWritten;
    }
    fRet = TRUE;

    Error:
    return fRet;
}


//
// Serial IO-control
//
BOOL CComHandle::IOControl(const DWORD dwCode, const BYTE* const pBufIn, const DWORD dwLenIn, BYTE* const pBufOut,
                           const DWORD dwLenOut, DWORD& rdwActualOut) const
{
    // FUNCTION_TRACE(CComHandle::IOControl);
    BOOL fRet = FALSE;

    if (!m_fInited || !m_fPortOpened || INVALID_HANDLE_VALUE == m_hDownstream)
    {
        goto Error;
    }

    fRet = DeviceIoControl(m_hDownstream, dwCode, (void*)pBufIn, dwLenIn, pBufOut, dwLenOut, &rdwActualOut, NULL);

    Error:
    return fRet;
}





DWORD WINAPI WCETimeoutThread(LPVOID lpParameter)
{
    FUNCTION_TRACE(WCETimeoutThread);
    WCETIMEOUT_THREAD_DATA* pParams = (WCETIMEOUT_THREAD_DATA*)lpParameter;

    if (WAIT_TIMEOUT == WaitForSingleObject(pParams->hCancelEvent, pParams->dwTimeout))
    {
        // We timed out -- cancel WaitCommEvent() in progress
        DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : t : WCETimeoutThread : Timed-out - Cancelling WaitCommEvent()\r\n")));
        (void)SetCommMask(pParams->hPort, DEFAULT_COM_MASK);
    }
    return 0;
}


//
//
//
BOOL CComHandle::WaitCommEventWithTimeout(DWORD dwTimeout, DWORD& rdwMask)
{
    // FUNCTION_TRACE(CComHandle::WaitCommEventWithTimeout);
    WCETIMEOUT_THREAD_DATA params;
    DWORD dwThreadID;
    HANDLE hThread = NULL;
    BOOL fRet = FALSE;

    rdwMask = 0;

    params.dwTimeout = dwTimeout;
    params.hPort = m_hDownstream;
    params.hCancelEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    if (!params.hCancelEvent)
    {
        DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : CComHandle::WaitCommEventWithTimeout : CreateEvent failed\r\n")));
        goto Error;
    }

    hThread = CreateThread(NULL, 0, WCETimeoutThread, (LPVOID)&params, 0, &dwThreadID);
    if (!hThread)
    {
        DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : CComHandle::WaitCommEventWithTimeout : CreateThread failed\r\n")));
        goto Error;
    }

    if (!DOWNST_WAITCOMMEVENT(m_hDownstream, &rdwMask))
    {
        DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : CComHandle::WaitCommEventWithTimeout : DOWNST_WAITCOMMEVENT failed\r\n")));
        goto Error;
    }
    fRet = !!rdwMask;

    Error:
    (void)SetEvent(params.hCancelEvent);
    (void)CloseHandle(hThread);
    (void)CloseHandle(params.hCancelEvent);
    return fRet;
}


//
// NOTE: multiple calls to this without corresponding calls to ExitDataMode() are OK.
//
BOOL CComHandle::EnterDataMode(const LPCSTR szData, const UINT cbData)
{

#ifndef DEDICATED_DATA_PORT

    // FUNCTION_TRACE(CComHandle::EnterDataMode);
    DEBUGCHK(FALSE != m_fInited);
    DEBUGCHK(FALSE != m_fPortOpened);
    DEBUGCHK(m_hDownstream != INVALID_HANDLE_VALUE);
    DEBUGCHK(m_pBuffer != NULL);

    BOOL fRet = FALSE;

    {
        SYNCBLOCK(m_csDataMode);

        // Switch to data mode and store the supplied data in the backup buffer
        m_fDataMode = TRUE;

        if (cbData && !m_pBuffer->Append(szData, cbData))
        {
            DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : CComHandle::EnterDataMode : cbData and Append failed\r\n")));
            goto Error;
        }
        DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : t : CComHandle::EnterDataMode : Entered data mode, stored %d bytes in the buffer\r\n"), cbData));

        // Make sure to block anyone who waits for command mode
        if (!ResetEvent(m_hCommandModeEvent))
        {
            DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : CComHandle::EnterDataMode : ResetEvent failed\r\n")));
            goto Error;
        }
    }
    fRet = TRUE;

    Error:
    return fRet;
#else

    //
    // For the dual port implementation, we never set m_fDataMode to TRUE
    // But you could signal a named event so that the driver handling the
    // data port knows that the RIL has successfully activated data mode
    //

    SetEvent(m_hDataModeEvent);

    return TRUE;

#endif

}


//
//
//
BOOL CComHandle::ExitDataMode()
{

#ifndef DEDICATED_DATA_PORT

    // FUNCTION_TRACE(CComHandle::ExitDataMode);
    DEBUGCHK(FALSE != m_fInited);
    DEBUGCHK(FALSE != m_fPortOpened);
    DEBUGCHK(m_hDownstream != INVALID_HANDLE_VALUE);

    char szBuf[1024];
    BOOL fRead;
    DWORD dwRead;
    BOOL fRet = FALSE;

    {
        SYNCBLOCK(m_csDataMode);

        // If we're not in data mode already, do nothing
        if (!m_fDataMode)
        {
            fRet = TRUE;
            goto Error;
        }

        // We're not in data mode anymore
        m_fDataMode = FALSE;
    }

    // Make sure no handle owns the VSP anymore
    (void)ClearOwner(m_pOwner);

    // Clear the backup data buffer
    delete[] m_pBuffer->GiveUpData();

    // Read any data still buffered on the downstream port
    do
    {
        fRead = DOWNST_READFILE(m_hDownstream, szBuf, 1024, &dwRead);
        if (fRead && dwRead)
        {
#ifdef DEBUG
            DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : t : CComHandle::ExitDataMode : Read bytes(2): %s\r\n"), TString(PrintableString(szBuf, dwRead))));
#endif // DEBUG
        }
    } while (fRead && dwRead);

    // Re-initialize COM port for RIL use
    if (!InitComPortForRIL(NULL, NULL))
    {
        DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : CComHandle::ExitDataMode : InitComPortForRIL failed\r\n")));
        goto Error;
    }

    // Make sure to release anyone waiting for command mode
    if (!SetEvent(m_hCommandModeEvent))
    {
        DEBUGMSG(ZONE_ERROR, (TEXT("RILDrv : E : CComHandle::ExitDataMode : SetEvent failed\r\n")));
        goto Error;
    }
    fRet = TRUE;

    Error:
    return fRet;

#else

    //
    // For the dual port implementation, we never set m_fDataMode to TRUE
    // But you could reset a named event so that the driver handling the
    // data port knows that the RIL has deactivated data mode
    // (either by an explicit hangup request or by notification from the radio)
    //

    ResetEvent(m_hDataModeEvent);

    return TRUE;

#endif
}


//
//
//
BOOL CComHandle::FDataMode()
{
    // FUNCTION_TRACE(CComHandle::FDataMode);
    SYNCBLOCK(m_csDataMode);
    return m_fDataMode;
}

#ifndef DEDICATED_DATA_PORT
BOOL CComHandle::FDataModeInterrupted()
{
    return (WaitForSingleObject(m_hDataModeInterrupted, 0) == WAIT_OBJECT_0);
}

void CComHandle::ResetDataModeInterrupted()
{
    ResetEvent(m_hDataModeInterrupted);
}
#endif


//
//
//
BOOL CComHandle::WaitForCommandMode() const
{
    // FUNCTION_TRACE(CComHandle::WaitForCommandMode);
    HANDLE rgEvents[2] = { m_hCommandModeEvent, m_hCancelEvent};

    return (WAIT_OBJECT_0 == WaitForMultipleObjects(2, rgEvents, FALSE, INFINITE));
}


//
//
//
BOOL CComHandle::GetDTRDropResponse(CRilHandle* const pRilDevice)
{
    // FUNCTION_TRACE(CComHandle::GetDTRDropResponse);
    char szData[1024];
    DWORD dwRead;
    CBuffer bufTemp;
    LPSTR szTotal;
    LPCSTR szRemainder = NULL;
    BYTE* pbRemainder = NULL;
    UINT cbTotal;
    UINT cbDataBeforeOK;
    UINT cbDataAfterOK;
    DWORD dwMask;
    DWORD dwErrors;
    BOOL fWaitCommEvent = FALSE;
    BOOL fRet = FALSE;

    while (1)
    {
        DEBUGMSG(ZONE_TRACE, (TEXT("RILDrv : t : CComHandle::GetDTRDropResponse : calling WaitCommEventWithTimeout\r\n")));

        // Wait for data