pdds3c6410_ser.h

6410BSP3

// WaterMarker Pairs.
typedef struct  __PAIRS
{
    ULONG   Key;
    ULONG   AssociatedValue;
} PAIRS, *PPAIRS;

static const UINT UDIVSLOT_TABLE[16] = 
{
    0x0000, 0x0080, 0x0808, 0x0888, 0x2222, 0x4924, 0x4A52, 0x54AA,
    0x5555, 0xD555, 0xD5D5, 0xDDD5, 0xDDDD, 0xDFDD, 0xDFDF, 0xFFDF
};

class CReg6410Uart
{
public:
    CReg6410Uart(PULONG pRegAddr);
    virtual ~CReg6410Uart() { ; };
    virtual BOOL    Init() ;
    // We do not virtual Read & Write data because of Performance Concern.
    void    Write_ULCON(ULONG uData) { WRITE_REGISTER_ULONG( m_pReg, (uData)); };
    ULONG   Read_ULCON() { return (READ_REGISTER_ULONG(m_pReg)); } ;
    void    Write_UCON (ULONG uData) { WRITE_REGISTER_ULONG(m_pReg+1 , uData); };
    ULONG   Read_UCON() { return READ_REGISTER_ULONG(m_pReg+1 ); };
    void    Write_UFCON(ULONG uData) { WRITE_REGISTER_ULONG( m_pReg+2, uData);};
    ULONG   Read_UFCON() { return READ_REGISTER_ULONG(m_pReg + 2); };
    void    Write_UMCON(ULONG uData) { WRITE_REGISTER_ULONG(m_pReg + 3, uData);};
    ULONG   Read_UMCON() { return READ_REGISTER_ULONG(m_pReg + 3);};
    ULONG   Read_UTRSTAT() { return READ_REGISTER_ULONG(m_pReg + 4);};
    ULONG   Read_UERSTAT() { return READ_REGISTER_ULONG(m_pReg + 5);};
    ULONG   Read_UFSTAT() { return READ_REGISTER_ULONG(m_pReg + 6);};
    ULONG   Read_UMSTAT() { return READ_REGISTER_ULONG(m_pReg + 7);};
    void    Write_UTXH (UINT8 uData) { WRITE_REGISTER_ULONG( (m_pReg + 8), uData) ; };
    UINT8   Read_URXH() { return (UINT8) READ_REGISTER_ULONG(m_pReg + 9); };
    void    Write_UBRDIV(ULONG uData) { WRITE_REGISTER_ULONG( m_pReg + 10, uData );};
    ULONG   Read_UBRDIV() { return READ_REGISTER_ULONG(m_pReg + 10); };
    void    Write_UDIVSLOT(ULONG uData) { WRITE_REGISTER_ULONG( (m_pReg + 11), uData) ; };
    ULONG    Read_UDIVSLOT() { return READ_REGISTER_ULONG(m_pReg + 11); };
    void    Write_UINTP(ULONG uData) { WRITE_REGISTER_ULONG( (m_pReg + 12), uData) ; };
    ULONG    Read_UINTP() { return READ_REGISTER_ULONG(m_pReg + 12); };
    void    Write_UINTSP(ULONG uData) { WRITE_REGISTER_ULONG( (m_pReg + 13), uData) ; };
    ULONG    Read_UINTSP() { return READ_REGISTER_ULONG(m_pReg + 13); };
    void    Write_UINTM(ULONG uData) { WRITE_REGISTER_ULONG( (m_pReg + 14), uData) ; };
    ULONG    Read_UINTM() { return READ_REGISTER_ULONG(m_pReg + 14); };    

    virtual BOOL    Write_BaudRate(ULONG uData);
    PULONG  GetRegisterVirtualAddr() { return m_pReg; };
    virtual void    Backup();
    virtual void    Restore();
#ifdef DEBUG
    virtual void    DumpRegister();
#endif
protected:
    volatile PULONG const  m_pReg;
    BOOL    m_fIsBackedUp;
private:
    ULONG    m_ULCONBackup;
    ULONG    m_UCONBackup;
    ULONG    m_UFCONBackup;
    ULONG    m_UMCOMBackup;
    ULONG    m_UBRDIVBackup;
    ULONG    m_UDIVSLOTBackup;
    ULONG    m_UINTMBackup;

    ULONG    m_BaudRate;
    ULONG    m_s3c6410_pclk;
};
class CPdd6410Uart: public CSerialPDD, public CMiniThread
{
public:
    CPdd6410Uart (LPTSTR lpActivePath, PVOID pMdd, PHWOBJ pHwObj);
    virtual ~CPdd6410Uart();
    virtual BOOL Init();
    virtual void PostInit();
    virtual BOOL MapHardware();
    virtual BOOL CreateHardwareAccess();
    //  Power Manager Required Function.
    virtual void    SerialRegisterBackup() { m_pReg6410Uart->Backup(); };
    virtual void    SerialRegisterRestore() { m_pReg6410Uart->Restore(); };

// Implement CPddSerial Function.
    virtual BOOL SetDCB(LPDCB lpDCB) {
        BOOL success;

        success = CSerialPDD::SetDCB(lpDCB);

        if (success) {  
            if (m_UseAutoFlow) {

                m_HardwareLock.Lock();

                DWORD dwBit = m_pReg6410Uart->Read_UMCON();

                dwBit &= ~UART_MCR_AUTO_FLOW_MASK;
                dwBit &= ~UART_MCR_RTS_RX_FIFO_TRIG_MASK;


                if (m_DCB.fOutxCtsFlow && (m_DCB.fRtsControl == RTS_CONTROL_HANDSHAKE)) {

                    dwBit |= UART_MCR_AUTO_FLOW_ENABLE | UART_MCR_RTS_RX_FIFO_TRIG_48;
                    m_AutoFlowEnabled = TRUE;          
                    RETAILMSG(1, (TEXT(" *** UART AutoFlow enabled: 0x%X  \r\n"),dwBit));
                } else {
                    m_AutoFlowEnabled = FALSE;
                }

                m_pReg6410Uart->Write_UMCON(dwBit); 

                m_HardwareLock.Unlock();
            }
        }

        return success;
    }

// Interrupt
    virtual BOOL    InitialEnableInterrupt(BOOL bEnable ) ; // Enable All the interrupt may include Xmit Interrupt.
private:
    virtual DWORD ThreadRun();   // IST
//
//  Tx Function.
public:
    virtual BOOL    InitXmit(BOOL bInit);
    virtual void    XmitInterruptHandler(PUCHAR pTxBuffer, ULONG *pBuffLen);
    virtual void    XmitComChar(UCHAR ComChar);
    virtual BOOL    EnableXmitInterrupt(BOOL bEnable);
    virtual BOOL    CancelXmit();
    virtual DWORD   GetWriteableSize();
protected:
    BOOL    m_XmitFifoEnable;
    HANDLE  m_XmitFlushDone;
//
//  Rx Function.
public:
    virtual BOOL    InitReceive(BOOL bInit);
    virtual ULONG   ReceiveInterruptHandler(PUCHAR pRxBuffer,ULONG *pBufflen);
    virtual ULONG   CancelReceive();
    virtual DWORD   GetWaterMark();
    virtual BYTE    GetWaterMarkBit();
    virtual void    Rx_Pause(BOOL bSet) {;};
protected:
    BOOL    m_bReceivedCanceled;
    DWORD   m_dwWaterMark;
//
//  Modem Function
public:
    virtual BOOL    InitModem(BOOL bInit);
    virtual void    ModemInterruptHandler() { GetModemStatus();};
    virtual ULONG   GetModemStatus();
    virtual void    SetDTR(BOOL bSet) {;};
    virtual void    SetRTS(BOOL bSet);
//
// Line Function.
    virtual BOOL    InitLine(BOOL bInit) ;
    virtual void    LineInterruptHandler() { GetLineStatus();};
    virtual void    SetBreak(BOOL bSet) ;
    virtual BOOL    SetBaudRate(ULONG BaudRate,BOOL bIrModule) ;
    virtual BOOL    SetByteSize(ULONG ByteSize);
    virtual BOOL    SetParity(ULONG Parity);
    virtual BOOL    SetStopBits(ULONG StopBits);
//
// Line Internal Function
    BYTE            GetLineStatus();
    virtual void    SetOutputMode(BOOL UseIR, BOOL Use9Pin) ;

protected:
    CReg6410Uart *  m_pReg6410Uart;
    PVOID           m_pRegVirtualAddr;
// Interrupt Function
public:
    void    DisableInterrupt(DWORD dwInt)
    { 
        m_pReg6410Uart->Write_UINTM(m_pReg6410Uart->Read_UINTM() | dwInt);
        m_pReg6410Uart->Write_UINTSP(dwInt);
    }
    void    EnableInterrupt(DWORD dwInt)
    { 
        m_pReg6410Uart->Write_UINTSP(dwInt);
        m_pReg6410Uart->Write_UINTM(m_pReg6410Uart->Read_UINTM() & ~dwInt);
    }
    void    ClearInterrupt(DWORD dwInt)
    {
        m_pReg6410Uart->Write_UINTSP(dwInt);
        m_pReg6410Uart->Write_UINTP(dwInt);
    }
    DWORD   GetInterruptStatus()
    { 
        return (m_pReg6410Uart->Read_UINTP()); 
    };
    DWORD   GetIntrruptMask ()
    { 
        return (~(m_pReg6410Uart->Read_UINTM()));
    };
    VOID SetClockSelect(DWORD ClockSelect) {
        m_ClockSelect = ClockSelect;
        m_ClockSelectValid = TRUE;
    }

    VOID AllowAutoFlow(BOOL Allow) {
        m_UseAutoFlow = Allow;
    }

protected:
    CRegistryEdit    m_ActiveReg;
    //  Interrupt Handler
    DWORD    m_dwSysIntr;
    HANDLE   m_hISTEvent;
    // Optional Parameter
    DWORD    m_dwDevIndex;
    DWORD    m_dwISTTimeout;
    DWORD    m_dwMemLen;
    BOOL    m_ClockSelectValid;
    DWORD    m_ClockSelect;
    BOOL    m_UseAutoFlow;
    BOOL    m_AutoFlowEnabled;
#ifdef USE_DMA
    DWORD 		m_dwTXDMAEnable;
    BOOL 			InitXmitDMA(void); 
    BOOL    		EnableTxDMA(BOOL fEnable);
    BOOL 			StopXmitDMA(void);
    BOOL 			StartXmitDMA(PUCHAR pTxBuffer, ULONG BuffLen);   
#endif
};

#endif