Subversion Repositories openrisc

//####COPYRIGHTBEGIN####

//                                                                          

// ----------------------------------------------------------------------------

// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.

//

// This program is part of the eCos host tools.

//

// This program is free software; you can redistribute it and/or modify it 

// under the terms of the GNU General Public License as published by the Free 

// Software Foundation; either version 2 of the License, or (at your option) 

// any later version.

// 

// This program is distributed in the hope that it will be useful, but WITHOUT 

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 

// more details.

// 

// You should have received a copy of the GNU General Public License along with

// this program; if not, write to the Free Software Foundation, Inc., 

// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

//

// ----------------------------------------------------------------------------

//                                                                          

//####COPYRIGHTEND####

//=================================================================

//

//        eCosSerial.cpp

//

//        Serial test class

//

//=================================================================

//=================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):     sdf

// Contributors:  sdf

// Date:          1999-04-01

// Description:   This class abstracts the serial port for use in the testing infrastructure

// Usage:

//

//####DESCRIPTIONEND####

#include "eCosStd.h"

#include "eCosSerial.h"

#include "eCosThreadUtils.h"

#include "eCosTrace.h"

CeCosSerial::CeCosSerial():

  m_nErr(0),

  m_pHandle(0),

  m_nDataBits(8),

  m_nStopBits(ONE_STOP_BIT),

  m_bXONXOFFFlowControl(0),

  m_bRTSCTSFlowControl(0),

  m_bDSRDTRFlowControl(0),

  m_bParity(false),

  m_nBaud(0),

  m_nTotalReadTimeout(10*1000),

  m_nTotalWriteTimeout(10*1000),

  m_nInterCharReadTimeout(500),

  m_nInterCharWriteTimeout(500),

  m_bBlockingReads(true)

{

}

CeCosSerial::~CeCosSerial()

{

  Close();

}

CeCosSerial::CeCosSerial(LPCTSTR pszPort,int nBaud):

  m_nErr(0),

  m_pHandle(0),

  m_nDataBits(8),

  m_nStopBits(ONE_STOP_BIT),

  m_bXONXOFFFlowControl(0),

  m_bRTSCTSFlowControl(0),

  m_bDSRDTRFlowControl(0),

  m_bParity(false),

  m_nTotalReadTimeout(10*1000),

  m_nTotalWriteTimeout(10*1000),

  m_nInterCharReadTimeout(500),

  m_nInterCharWriteTimeout(500),

  m_bBlockingReads(true)

{

  Open(pszPort,nBaud);

}

bool CeCosSerial::SetBlockingReads(bool b,bool bApplySettingsNow/*=true*/)

{

  m_bBlockingReads=b;

  return 0==m_pHandle || !bApplySettingsNow || ApplySettings();

}

bool CeCosSerial:: SetBaud(unsigned int nBaud,bool bApplySettingsNow/*=true*/)

{

  m_nBaud=nBaud;

  return 0==m_pHandle || !bApplySettingsNow || ApplySettings();

}

bool CeCosSerial:: SetParity(bool bParityOn,bool bApplySettingsNow/*=true*/)

{

  m_bParity=bParityOn;

  return 0==m_pHandle || !bApplySettingsNow || ApplySettings();

}

bool CeCosSerial:: SetDataBits(int n,bool bApplySettingsNow/*=true*/)

{

  m_nDataBits=n;

  return 0==m_pHandle || !bApplySettingsNow || ApplySettings();

}

bool CeCosSerial:: SetStopBits(StopBitsType n,bool bApplySettingsNow/*=true*/)

{

  m_nStopBits=n;

  return 0==m_pHandle || !bApplySettingsNow || ApplySettings();

}

bool CeCosSerial:: SetXONXOFFFlowControl(bool b,bool bApplySettingsNow/*=true*/)

{

  m_bXONXOFFFlowControl=b;

  return 0==m_pHandle || !bApplySettingsNow || ApplySettings();

}

bool CeCosSerial:: SetRTSCTSFlowControl(bool b,bool bApplySettingsNow/*=true*/)

{

  m_bRTSCTSFlowControl=b;

  return 0==m_pHandle || !bApplySettingsNow || ApplySettings();

}

bool CeCosSerial:: SetDSRDTRFlowControl(bool b,bool bApplySettingsNow/*=true*/)

{

  m_bDSRDTRFlowControl=b;

  return 0==m_pHandle || !bApplySettingsNow || ApplySettings();

}

bool CeCosSerial:: SetReadTimeOuts(int nTotal,int nBetweenChars,bool bApplySettingsNow/*=true*/) // mSec

{

  m_nTotalReadTimeout=nTotal;

  m_nInterCharReadTimeout=nBetweenChars;

  return 0==m_pHandle || !bApplySettingsNow || ApplySettings();

}

bool CeCosSerial:: SetWriteTimeOuts(int nTotal,int nBetweenChars,bool bApplySettingsNow/*=true*/) // mSec

{

  m_nTotalWriteTimeout=nTotal;

  m_nInterCharWriteTimeout=nBetweenChars;

  return 0==m_pHandle || !bApplySettingsNow || ApplySettings();

}

#ifdef _WIN32

bool CeCosSerial::Open(LPCTSTR pszPort,int nBaud)

{

  bool rc=false;

  m_nBaud=nBaud,

    m_strPort=pszPort;

  HANDLE hCom=::CreateFile(pszPort,GENERIC_READ|GENERIC_WRITE, 0,NULL,OPEN_EXISTING,0,NULL);

  SaveError();

  if (INVALID_HANDLE_VALUE==hCom) {

    ERROR(_T("Failed to open port %s - %s\n"),pszPort,(LPCTSTR)ErrString());

  } else {

    m_pHandle=(void *)hCom;

    if(ApplySettings()){

      Flush();

      rc=true;

    } else {

      Close();

    }

  }

  return rc;

}

bool CeCosSerial::Close()

{

  bool rc=false;

  if(m_pHandle){

    try {

      rc=(TRUE==CloseHandle((HANDLE)m_pHandle));

    }

    catch(...) {

      TRACE(_T("!!! Exception caught closing serial handle %08x\n"),m_pHandle);

    }

    m_pHandle=0;

  } else {

    rc=true;

  }

  return rc;

}

bool CeCosSerial::ApplySettings()

{

  bool rc=false;

  try {

    DCB dcb;

    ZeroMemory(&dcb,sizeof dcb);

    dcb.DCBlength=sizeof dcb;

    dcb.BaudRate=m_nBaud;

    dcb.fBinary=true;

    dcb.fParity=true;

    dcb.Parity=(BYTE) ((m_bParity) ? EVENPARITY : NOPARITY);

    dcb.StopBits=(BYTE)m_nStopBits;

    dcb.ByteSize=(BYTE)m_nDataBits;

    LPCTSTR arpszStopbits[3]={_T("1"),_T("1.5"),_T("2")};

    TRACE(_T("Applysettings baud=%d Parity=%d stopbits=%s databits=%d\n"),

      dcb.BaudRate,

      dcb.Parity,

      arpszStopbits[dcb.StopBits],

      dcb.ByteSize);

    if (m_bDSRDTRFlowControl) {

        dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;

        dcb.fOutxDsrFlow = 1;

    } else {

        dcb.fDtrControl = DTR_CONTROL_ENABLE;

        dcb.fOutxDsrFlow = 0;

    }

    if (m_bRTSCTSFlowControl) {

        dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;

        dcb.fOutxCtsFlow = 1;

    } else {

        dcb.fRtsControl = RTS_CONTROL_ENABLE;

        dcb.fOutxCtsFlow = 0;

    }

    dcb.fTXContinueOnXoff=1;

    dcb.XonChar=17;

    dcb.XoffChar=19;

    if (m_bXONXOFFFlowControl) {

        dcb.XonLim=512;

        dcb.XoffLim=512;

        dcb.fOutX=1;

        dcb.fInX=1;

    } else {

        dcb.XonLim=2048;

        dcb.XoffLim=512;

        dcb.fOutX=0;

        dcb.fInX=0;

    }

    dcb.fAbortOnError=1;

    HANDLE hCom=(HANDLE)m_pHandle;

    if (!SetCommState(hCom, &dcb)) {

      SaveError();

                    ERROR(_T("Failed to set comm state - port %s handle=%d err=%d\n"),(LPCTSTR)m_strPort,hCom,GetLastError());

    } else {

                    COMMTIMEOUTS commtimeouts;

        if(m_bBlockingReads){

                        commtimeouts.ReadIntervalTimeout=m_nInterCharReadTimeout;

            commtimeouts.ReadTotalTimeoutMultiplier=0;

            commtimeouts.ReadTotalTimeoutConstant=m_nTotalReadTimeout;

        } else {

                        commtimeouts.ReadIntervalTimeout=MAXDWORD;

            commtimeouts.ReadTotalTimeoutMultiplier=0;

            commtimeouts.ReadTotalTimeoutConstant=0;

        }

        commtimeouts.WriteTotalTimeoutMultiplier=m_nTotalWriteTimeout;

        commtimeouts.WriteTotalTimeoutConstant=m_nInterCharWriteTimeout;

        if (SetCommTimeouts(hCom, &commtimeouts)) {

          rc=true;

        } else {

          SaveError();

          ERROR(_T("Failed to set comm timeouts - port %s\n"),(LPCTSTR)m_strPort);

        }

    }

  }

  catch(...)

  {

    TRACE(_T("!!! Exception caught in CeCosSerial::ApplySettings!!!\n"));

  }

  return rc;

}

bool CeCosSerial::Read (void *pBuf,unsigned int nSize,unsigned int &nRead)

{

  bool rc=(TRUE==ReadFile((HANDLE)m_pHandle,pBuf,nSize,(LPDWORD)&nRead,0));

  SaveError();

  return rc;

}

bool CeCosSerial::Write(void *pBuf,unsigned int nSize,unsigned int &nWritten)

{

  bool rc=(TRUE==WriteFile((HANDLE)m_pHandle,pBuf,nSize,(LPDWORD)&nWritten,0));

  SaveError();

  return rc;

}

bool CeCosSerial::ClearError()

{

  DWORD dwErrors;

  bool rc=(TRUE==ClearCommError(HANDLE(m_pHandle),&dwErrors,0));

  if(dwErrors&CE_BREAK)TRACE(_T("The hardware detected a break condition.\n"));

  if(dwErrors&CE_DNS)TRACE(_T("Windows 95 and Windows 98: A parallel device is not selected.\n"));

  if(dwErrors&CE_FRAME)TRACE(_T("The hardware detected a framing error.\n"));

  if(dwErrors&CE_IOE)TRACE(_T("An I/O error occurred during communications with the device.\n"));

  if(dwErrors&CE_MODE)TRACE(_T("The requested mode is not supported, or the hFile parameter is invalid. If this value is specified, it is the only valid error.\n"));

  if(dwErrors&CE_OOP)TRACE(_T("Windows 95 and Windows 98: A parallel device signaled that it is out of paper.\n"));

  if(dwErrors&CE_OVERRUN)TRACE(_T("A character-buffer overrun has occurred. The next character is lost.\n"));

  if(dwErrors&CE_PTO)TRACE(_T("Windows 95 and Windows 98: A time-out occurred on a parallel device.\n"));

  if(dwErrors&CE_RXOVER)TRACE(_T("An input buffer overflow has occurred. There is either no room in the input buffer, or a character was received after the end-of-file (EOF) character.\n"));

  if(dwErrors&CE_RXPARITY)TRACE(_T("The hardware detected a parity error.\n"));

  if(dwErrors&CE_TXFULL)TRACE(_T("The application tried to transmit a character, but the output buffer was full.\n"));

  return rc;

}

bool CeCosSerial::Flush (void)

{

  bool rc=(TRUE==PurgeComm ((HANDLE)m_pHandle,PURGE_TXCLEAR|PURGE_RXCLEAR));

  SaveError();

  return rc;

}

String CeCosSerial::ErrString() const

{

  String str;

  LPVOID lpMsgBuf;

  FormatMessage(

    FORMAT_MESSAGE_ALLOCATE_BUFFER |

    FORMAT_MESSAGE_FROM_SYSTEM |

    FORMAT_MESSAGE_IGNORE_INSERTS,

    NULL,

    m_nErr,

    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language

    (LPTSTR) &lpMsgBuf,

    0,

    NULL

    );

  str=(LPCTSTR)lpMsgBuf;

  // Free the buffer.

  LocalFree( lpMsgBuf );

  return str;

}

#else // UNIX

String CeCosSerial::ErrString() const

{

  return strerror(errno);

}

bool CeCosSerial::Close()

{

  bool rc=m_pHandle && (-1!=close((int)m_pHandle));

  m_pHandle=0;

  return rc;

}

bool CeCosSerial::Open(LPCTSTR pszPort,int nBaud)

{

  bool rc=false;

  m_nBaud=nBaud,

    m_strPort=pszPort;

  int fd = open(pszPort,O_RDWR|O_NONBLOCK);

  if (-1==fd) {

    ERROR(_T("Failed to open port %s\n"),pszPort);

    return false;

  } else {

    m_pHandle=(void *)fd;

    if(ApplySettings()){

      rc=true;

    } else {

      Close();

      ERROR(_T("Failed to apply settings.\n"));

      return false;

    }

  }

  return rc;

}

bool CeCosSerial::ApplySettings()

{

  struct termios buf, buf_verify;

  int rate;

  // Clear the two structures so we can make a binary comparison later on.

  memset(&buf, 0, sizeof(buf));

  memset(&buf_verify, 0, sizeof(buf_verify));

  LPCTSTR arpszStopbits[3]={_T("1"),_T("1.5"),_T("2")};

  TRACE(_T("Applysettings baud=%d bParity=%d stopbits=%s databits=%d\n"),

    m_nBaud,

    m_bParity,

    arpszStopbits[m_nStopBits],

    m_nDataBits);

  switch(m_nBaud) {

  case 110:

    rate = B110;

    break;

  case 150:

    rate = B150;

    break;

  case 300:

    rate = B300;

    break;

  case 600:

    rate = B600;

    break;

  case 1200:

    rate = B1200;

    break;

  case 2400:

    rate = B2400;

    break;

  case 4800:

    rate = B4800;

    break;

  case 9600:

    rate = B9600;

    break;

  case 19200:

    rate = B19200;

    break;

  case 38400:

    rate = B38400;

    break;

  case 57600:

    rate = B57600;

    break;

  case 115200:

    rate = B115200;

    break;

  default:

    return false;

  };

  TRACE(_T("Changing configuration...\n"));

  // Get current settings.

  if (tcgetattr((int) m_pHandle, &buf)) {

    fprintf(stderr, _T("Error: tcgetattr\n"));

    return false;

  }

  // Reset to raw.

  buf.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP

    |INLCR|IGNCR|ICRNL|IXON);

  buf.c_oflag &= ~OPOST;

  buf.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);

  buf.c_cflag &= ~(CSIZE|PARENB);

  buf.c_cflag |= CS8;

  // Set baud rate.

  cfsetispeed(&buf, rate);

  cfsetospeed(&buf, rate);

  // Set data bits.

  {

    int data_bits[9] = {0, 0, 0, 0, 0, CS5, CS6, CS7, CS8};

    buf.c_cflag &= ~CSIZE;

    buf.c_cflag |= data_bits[m_nDataBits];

  }

  // Set stop bits.

  {

    buf.c_cflag &= ~CSTOPB;

    if (ONE_STOP_BIT != m_nStopBits)

      buf.c_cflag |= CSTOPB;

  }

  // Set parity.

  {

    buf.c_cflag &= ~(PARENB | PARODD); // no parity.

    if (m_bParity)                  // even parity.

      buf.c_cflag |= PARENB;

  }

  // Set flow control

  {

      buf.c_iflag &= ~(IXON|IXOFF);

#ifdef CRTSCTS

      buf.c_cflag &= ~CRTSCTS;

#endif

      if ( m_bXONXOFFFlowControl ) {

          buf.c_iflag |= (IXON|IXOFF);

      }

      if ( m_bRTSCTSFlowControl ) {

#ifdef CRTSCTS

          buf.c_cflag |= CRTSCTS;

#else

          return false;

#endif

      }

      if ( m_bDSRDTRFlowControl ) {

#ifdef CDSRDTR

          buf.c_cflag |= CDSRDTR;

#else

          return false;

#endif

      }

  }

  // Set the new settings

  if (tcsetattr((int) m_pHandle, TCSADRAIN, &buf)) {

    fprintf(stderr, _T("Error: tcsetattr\n"));

    return false;

  }

  // Now read back the settings. On SunOS tcsetattr only returns

  // error if _all_ settings fail. If just a few settings are not

  // supported, the call returns true while the hardware is set to a

  // combination of old and new settings.

  if (tcgetattr((int) m_pHandle, &buf_verify)) {

    fprintf(stderr, _T("Error: tcgetattr\n"));

    return false;

  }

  if (memcmp(&buf, &buf_verify, sizeof(buf))) {

    fprintf(stderr, _T("Error: termios verify failed\n"));

    return false;

  }

  // A slight delay to allow things to settle.

  CeCosThreadUtils::Sleep(10);

  TRACE(_T("Done.\n"));

  return true;

}

bool CeCosSerial::Flush (void)

{

  return 0==tcflush((int) m_pHandle, TCIOFLUSH);

}

bool CeCosSerial::Read (void *pBuf,unsigned int nSize,unsigned int &nRead)

{

  if (!m_bBlockingReads) {

    nRead = 0;

    int n = read((int)m_pHandle, pBuf, nSize);

    if (-1 == n) {

      if (EAGAIN == errno)

        return true;

      ERROR(_T("Read failed: %d\n"), errno);

      return false;

    }

    nRead = n;

#if 0

    if (n>0) {

        unsigned int i;

        fprintf(stderr, "%d:", nRead);

        for (i = 0; i < nRead; i++)

            fprintf(stderr, "%02x!", ((unsigned char *)pBuf)[i]);

        fprintf(stderr, "\n");

    }

#endif

    return true;

  }

  // Blocking reads: emulate the Windows semantics:

  //  If m_nTotalReadTimeout elapses before we see the first TCHAR, 

  //   return.

  //  If m_nInterCharReadTimeout elapses after reading any

  //   subsequent TCHAR, return.

  fd_set rfds;

  FD_ZERO(&rfds);

  FD_SET((int)m_pHandle, &rfds);

  // Start with total timeout.

  struct timeval tv;

  tv.tv_sec = m_nTotalReadTimeout / 1000;

  tv.tv_usec = (m_nTotalReadTimeout % 1000) * 1000;

  unsigned char* pData = (unsigned char*) pBuf;

  nRead = 0;

  while (nSize) {

    switch(select((int)m_pHandle + 1, &rfds, NULL, NULL, &tv)) {

    case 1:

      {

        int n = read((int)m_pHandle, pData, nSize);

        if (-1 == n && EAGAIN != errno) {

          ERROR(_T("Read failed: %d\n"), errno);

          return false;           // FAILED

        }

        else if (n > 0) {

#if 0

            unsigned int i;

            fprintf(stderr, "%d:", nRead);

            for (i = 0; i < nRead; i++)

                fprintf(stderr, "%02x!", ((unsigned char *)pBuf)[i]);

            fprintf(stderr, "\n");

#endif

            nRead += n;

            pData += n;

            nSize -= n;

        }

        // Now use inter-char timeout.

        tv.tv_sec = m_nInterCharReadTimeout / 1000;

        tv.tv_usec = (m_nInterCharReadTimeout % 1000) * 1000;

      }

      break;

    case 0:

      return true;                // Timeout 

    case -1:

      ERROR(_T("Select failed: %d\n"), errno);

      return false;

    }

  }

  return true;

}

bool CeCosSerial::Write(void *pBuf,unsigned int nSize,unsigned int &nWritten)

{

  bool rc;

  int n=write((int)m_pHandle,pBuf,nSize);

  if(-1==n){

    nWritten=0;

    if (errno == EAGAIN)

      rc = true;

    else

      rc=false;

  } else {

    nWritten=n;

    rc=true;

  }

  return rc;

}

bool CeCosSerial::ClearError()

{

  return false;

}

#endif