pdd16550.cpp

wince下的串口驱动源码

DWORD   CPdd16550::GetWriteableSize()
{
    DWORD dwWriteSize = 0;
    if (GetLineStatus() & SERIAL_LSR_THRE )
        dwWriteSize = (m_XmitFifoEnable?SERIAL_FIFO_DEPTH:1);
    return dwWriteSize;
}
void    CPdd16550::XmitInterruptHandler(PUCHAR pTxBuffer, ULONG *pBuffLen)
{
    PREFAST_DEBUGCHK(pBuffLen!=NULL);
    m_HardwareLock.Lock();    
    if (*pBuffLen == 0) 
        EnableXmitInterrupt(FALSE);
    else {
        DEBUGCHK(pTxBuffer);
        PulseEvent(m_XmitFlushDone);
        DWORD dwDataAvaiable = *pBuffLen;
        *pBuffLen = 0;
        if ((m_DCB.fOutxCtsFlow && IsCTSOff()) ||(m_DCB.fOutxDsrFlow && IsDSROff())) { // We are in flow off
            DEBUGMSG(ZONE_THREAD|ZONE_WRITE,(TEXT("CPdd16550::XmitInterruptHandler! Flow Off, Data Discard.\r\n")));
            EnableXmitInterrupt(FALSE);
        }
        else  {
            DWORD dwWriteSize = GetWriteableSize();
            for (DWORD dwByteWrite=0; dwByteWrite<dwWriteSize && dwDataAvaiable!=0;dwByteWrite++) {
                m_pReg16550->Write_DATA(*pTxBuffer);
                pTxBuffer ++;
                dwDataAvaiable--;
            }
            DEBUGMSG(ZONE_THREAD|ZONE_WRITE,(TEXT("CPdd16550::XmitInterruptHandler! Write %d byte to FIFO\r\n"),dwByteWrite));
            *pBuffLen = dwByteWrite;
            EnableXmitInterrupt(TRUE);        
        }
    }
    m_HardwareLock.Unlock();
}
void    CPdd16550::XmitComChar(UCHAR ComChar)
{
    // This function has to poll until the Data can be sent out.
    BOOL bDone = FALSE;
    do {
        m_HardwareLock.Lock(); 
        if ( GetLineStatus() & SERIAL_LSR_THRE ) {  // If Empty.
            m_pReg16550->Write_DATA(ComChar);
            bDone = TRUE;
        }
        else {
            EnableXmitInterrupt(TRUE);
        }
        m_HardwareLock.Unlock();
        if (!bDone)
           WaitForSingleObject(m_XmitFlushDone, (ULONG)1000); 
    }
    while (!bDone);
}
BOOL    CPdd16550::EnableXmitInterrupt(BOOL fEnable)
{
    m_HardwareLock.Lock();
    if (fEnable)
        m_pReg16550->Write_IER ( m_pReg16550->Read_IER() | SERIAL_IER_THR);
    else
         m_pReg16550->Write_IER ( m_pReg16550->Read_IER() & ~SERIAL_IER_THR);
    m_HardwareLock.Unlock();
    return TRUE;
        
}
BOOL  CPdd16550::CancelXmit()
{
    m_HardwareLock.Lock();
    m_pReg16550->Write_FCR(m_pReg16550->Read_FCR() | SERIAL_FCR_TXMT_RESET | SERIAL_FCR_ENABLE);
    m_HardwareLock.Unlock();
    return FALSE;
    
}
static PAIRS s_HighWaterPairs[] = {
    {SERIAL_1_BYTE_HIGH_WATER, 0},
    {SERIAL_4_BYTE_HIGH_WATER, 4},
    {SERIAL_8_BYTE_HIGH_WATER, 8},
    {SERIAL_14_BYTE_HIGH_WATER, 14}
};

BYTE  CPdd16550::GetWaterMarkBit()
{
    BYTE bReturnKey = (BYTE)s_HighWaterPairs[0].Key;
    for (DWORD dwIndex=dim(s_HighWaterPairs)-1;dwIndex!=0; dwIndex --) {
        if (m_dwWaterMark>=s_HighWaterPairs[dwIndex].AssociatedValue) {
            bReturnKey = (BYTE)s_HighWaterPairs[dwIndex].Key;
            break;
        }
    }
    return bReturnKey;
}
DWORD   CPdd16550::GetWaterMark()
{
    BYTE bReturnValue = (BYTE)s_HighWaterPairs[0].AssociatedValue;
    for (DWORD dwIndex=dim(s_HighWaterPairs)-1;dwIndex!=0; dwIndex --) {
        if (m_dwWaterMark>=s_HighWaterPairs[dwIndex].AssociatedValue) {
            bReturnValue = (BYTE)s_HighWaterPairs[dwIndex].AssociatedValue;
            break;
        }
    }
    return bReturnValue;
}

// Receive
BOOL    CPdd16550::InitReceive(BOOL bInit)
{
    m_HardwareLock.Lock();    
    if (bInit) {         
        BYTE uWarterMarkBit = GetWaterMarkBit();
        if (uWarterMarkBit> 3)
            uWarterMarkBit = 3;
        m_pReg16550->Write_FCR(m_pReg16550->Read_FCR() | SERIAL_FCR_RCVR_RESET | SERIAL_FCR_ENABLE | (uWarterMarkBit<<6));        
        m_pReg16550->Write_IER(m_pReg16550->Read_IER() | SERIAL_IER_RDA);
        m_pReg16550->Read_LSR(); // Clean Line Interrupt.
    }
    else {
        m_pReg16550->Write_IER(m_pReg16550->Read_IER() & ~SERIAL_IER_RDA);
    }
    m_HardwareLock.Unlock();
    return TRUE;
}
ULONG   CPdd16550::ReceiveInterruptHandler(PUCHAR pRxBuffer,ULONG *pBufflen)
{
    DWORD dwBytesDropped = 0;
    if (pRxBuffer && pBufflen ) {
        DWORD dwBytesStored = 0 ;
        DWORD dwRoomLeft = *pBufflen;
        m_bReceivedCanceled = FALSE;
        m_HardwareLock.Lock();
        
        while (dwRoomLeft && !m_bReceivedCanceled) {
            UCHAR uLineStatus = GetLineStatus();
            if ((uLineStatus & SERIAL_LSR_DR)!=0 ) {
                UCHAR uData = m_pReg16550->Read_Data();
                if (DataReplaced(&uData,(uLineStatus & SERIAL_LSR_PE)!=0)) {
                    *pRxBuffer++ = uData;
                    dwRoomLeft--;
                    dwBytesStored++;                    
                }
            }
            else
                break;
        }
        if (m_bReceivedCanceled)
            dwBytesStored = 0;
        
        m_HardwareLock.Unlock();
        *pBufflen = dwBytesStored;
    }
    else {
        ASSERT(FALSE);
    }
    return dwBytesDropped;
}
ULONG   CPdd16550::CancelReceive()
{
    m_bReceivedCanceled = TRUE;
    m_HardwareLock.Lock();    
    m_pReg16550->Write_FCR(m_pReg16550->Read_FCR() | SERIAL_FCR_RCVR_RESET );
    m_HardwareLock.Unlock();
    return 0;
}
BOOL    CPdd16550::InitModem(BOOL bInit)
{
    m_HardwareLock.Lock();    
    if (bInit) {
        m_pReg16550->Write_MCR(SERIAL_MCR_IRQ_ENABLE);
        m_pReg16550->Write_IER( m_pReg16550->Read_IER() | SERIAL_IER_MS);
        m_pReg16550->Read_MSR(); // Clean the Interrupt First.
    }
    else {
        m_pReg16550->Write_MCR(0);
        m_pReg16550->Write_IER( m_pReg16550->Read_IER() & ~SERIAL_IER_MS);
    }
    m_HardwareLock.Unlock();
    return TRUE;
}
ULONG   CPdd16550::GetModemStatus()
{
    m_HardwareLock.Lock();    
    ULONG ulReturn =0 ;
    ULONG Events = 0;
    UINT8 ubModemStatus = m_pReg16550->Read_MSR();
    m_HardwareLock.Unlock();

    // Event Notification.
    if (ubModemStatus & SERIAL_MSR_DCTS)
        Events |= EV_CTS;
    if ( ubModemStatus  & SERIAL_MSR_DDSR )
        Events |= EV_DSR;
    if ( ubModemStatus  & SERIAL_MSR_TERI )
        Events |= EV_RING;
    if ( ubModemStatus  & SERIAL_MSR_DDCD )
        Events |= EV_RLSD;

    // Report Modem Status;
    if ( ubModemStatus & SERIAL_MSR_CTS )
        ulReturn |= MS_CTS_ON;
    if ( ubModemStatus & SERIAL_MSR_DSR )
         ulReturn |= MS_DSR_ON;
    if ( ubModemStatus & SERIAL_MSR_RI )
         ulReturn  |= MS_RING_ON;
    if ( ubModemStatus & SERIAL_MSR_DCD )
         ulReturn  |= MS_RLSD_ON;

    if (Events!=0)
        EventCallback(Events,ulReturn);
    
    return ulReturn;
}

void    CPdd16550::SetDTR(BOOL bSet)
{
    m_HardwareLock.Lock();
    BYTE bData = m_pReg16550->Read_MCR();
    if (bSet) {
        bData |= SERIAL_MCR_DTR;
    }
    else
        bData &= ~SERIAL_MCR_DTR;
    m_pReg16550->Write_MCR(bData);
    m_HardwareLock.Unlock();
}
void    CPdd16550::SetRTS(BOOL bSet)
{
    m_HardwareLock.Lock();
    BYTE bData = m_pReg16550->Read_MCR();
    if (bSet) {
        bData |= SERIAL_MCR_RTS;
    }
    else
        bData &= ~SERIAL_MCR_RTS;
    m_pReg16550->Write_MCR(bData);
    m_HardwareLock.Unlock();

}
BOOL CPdd16550::InitLine(BOOL bInit)
{
    m_HardwareLock.Lock();
    if  (bInit) {
        m_pReg16550->Write_IER( m_pReg16550->Read_IER() | SERIAL_IER_RLS);
        m_pReg16550->Write_LCR( SERIAL_8_DATA | SERIAL_1_STOP | SERIAL_NONE_PARITY);
    }
    else {
        m_pReg16550->Write_IER( m_pReg16550->Read_IER() & ~SERIAL_IER_RLS);
    }
    m_HardwareLock.Unlock();
    return TRUE;
}
BYTE CPdd16550::GetLineStatus()
{
    m_HardwareLock.Lock();
    BYTE bData = m_pReg16550->Read_LSR();
    m_HardwareLock.Unlock();  
    ULONG ulError = 0;
    if (bData & SERIAL_LSR_OE ) {
        ulError |=  CE_OVERRUN;
    }
    if (bData & SERIAL_LSR_PE) {
        ulError |= CE_RXPARITY;
    }
    if (bData & SERIAL_LSR_FE) {
        ulError |=  CE_FRAME;
    }
    if (ulError)
        SetReceiveError(ulError);
    if (bData & SERIAL_LSR_BI) {
         EventCallback(EV_BREAK);
    }
    return bData;
        
}
void    CPdd16550::SetBreak(BOOL bSet)
{
    m_HardwareLock.Lock();
    BYTE bData = m_pReg16550->Read_LCR();
    if (bSet)
        bData |= SERIAL_LCR_BREAK;
    else
        bData &= ~SERIAL_LCR_BREAK;
    m_pReg16550->Write_LCR(bData);
    m_HardwareLock.Unlock();      
}
BOOL    CPdd16550::SetBaudRate(ULONG BaudRate,BOOL /*bIrModule*/)
{
    ULONG ulDivisor;
    if (GetDivisorOfRate(BaudRate,&ulDivisor)) {
        m_HardwareLock.Lock();
        InterruptMask(m_dwSysIntr,TRUE);
        __try {
            m_pReg16550->Write_BaudRate((UINT16)ulDivisor);
        }__except( EXCEPTION_EXECUTE_HANDLER ) {
        };
        InterruptMask(m_dwSysIntr,FALSE);
        m_HardwareLock.Unlock();      
        return TRUE;
    }
    else
        return FALSE;
}
BOOL    CPdd16550::SetByteSize(ULONG ByteSize)
{
    BOOL bRet = TRUE;
    m_HardwareLock.Lock();
    UCHAR bData = m_pReg16550->Read_LCR() & ~SERIAL_DATA_MASK;;
    switch ( ByteSize ) {
    case 5:
        bData |= SERIAL_5_DATA;
        break;
    case 6:
        bData |= SERIAL_6_DATA;
        break;
    case 7:
        bData |= SERIAL_7_DATA;
        break;
    case 8:
        bData |= SERIAL_8_DATA;
        break;
    default:
        bRet = FALSE;
        break;
    }
    if (bRet) {
        m_pReg16550->Write_LCR(bData);
    }
    m_HardwareLock.Unlock();
    return bRet;
}
BOOL    CPdd16550::SetParity(ULONG Parity)
{
    BOOL bRet = TRUE;
    UCHAR bData = m_pReg16550->Read_LCR() & ~SERIAL_PARITY_MASK;
    switch ( Parity ) {
    case ODDPARITY:
        bData |= SERIAL_ODD_PARITY;
        break;
    case EVENPARITY:
        bData |= SERIAL_EVEN_PARITY;
        break;
    case MARKPARITY:
        bData |= SERIAL_MARK_PARITY;
        break;
    case SPACEPARITY:
        bData |= SERIAL_SPACE_PARITY;
        break;
    case NOPARITY:
        bData |= SERIAL_NONE_PARITY;
        break;
    default:
        bRet = FALSE;
        break;
    }
    if (bRet) {
        m_pReg16550->Write_LCR(bData);
    }
    return bRet;
}
BOOL    CPdd16550::SetStopBits(ULONG StopBits)
{
    BOOL bRet = TRUE;
    UCHAR bData = m_pReg16550->Read_LCR() & ~SERIAL_STOP_MASK;

    switch ( StopBits ) {
    case ONESTOPBIT :
        bData |= SERIAL_1_STOP ;
        break;
    case ONE5STOPBITS :
        bData |= SERIAL_1_5_STOP ;
        break;
    case TWOSTOPBITS :
        bData |= SERIAL_2_STOP ;
        break;
    default:
        bRet = FALSE;
        break;
    }
    if (bRet) {
        m_pReg16550->Write_LCR(bData);
    }
    return bRet;
}