Ignore:
Timestamp:
Sep 20, 2000, 11:32:58 PM (25 years ago)
Author:
hugh
Message:

Implemented Serial APIs

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/hmcomm.cpp

    r2802 r4285  
    1 /* $Id: hmcomm.cpp,v 1.4 2000-02-16 14:23:58 sandervl Exp $ */
     1/* $Id: hmcomm.cpp,v 1.5 2000-09-20 21:32:51 hugh Exp $ */
    22
    33/*
    … …  
    1010 */
    1111
    12 #include <odin.h>
    13 #include <win32type.h>
    14 #include <misc.h>
     12
     13
     14#include <os2win.h>
     15#include <string.h>
    1516#include "handlemanager.h"
    1617#include "hmdevice.h"
    … …  
    1819#include "oslibdos.h"
    1920
    20 #define DBG_LOCALLOG    DBG_hmcomm
     21#define DBG_LOCALLOG  DBG_hmcomm
    2122#include "dbglocal.h"
    2223
     24#define MAGIC_COM 0x12abcd34
     25
     26#define IOCTL_ASYNC          0x01
     27#define ASYNC_GETDCBINFO     0x73
     28#define ASYNC_SETDCBINFO     0x53
     29#define ASYNC_SETLINECTRL    0x42
     30#define ASYNC_GETCOMMEVENT   0x72
     31#define ASYNC_EXTGETBAUDRATE 0x63
     32#define ASYNC_EXTSETBAUDRATE 0x43
     33#define ASYNC_GETCOMMERROR   0x6D
     34#define ASYNC_GETCOMMSTATUS  0x65
     35#define ASYNC_GETINQUECOUNT  0x68
     36#define ASYNC_GETOUTQUECOUNT 0x69
     37#define ASYNC_GETMODEMINPUT  0x67
     38#define ASYNC_TRANSMITIMM    0x44
     39#define ASYNC_SETBREAKON     0x4B
     40#define ASYNC_SETBREAKOFF    0x45
     41#define ASYNC_SETMODEMCTRL   0x46
     42#define ASYNC_STARTTRANSMIT  0x48
     43#define ASYNC_STOPTRANSMIT   0x47
     44
     45
     46
     47#pragma pack(1)
     48typedef struct _DCBINFO
     49{
     50  USHORT   usWriteTimeout;         /*  Time period used for Write Timeout processing. */
     51  USHORT   usReadTimeout;          /*  Time period used for Read Timeout processing. */
     52  BYTE     fbCtlHndShake;          /*  HandShake Control flag. */
     53  BYTE     fbFlowReplace;          /*  Flow Control flag. */
     54  BYTE     fbTimeOut;              /*  Timeout flag. */
     55  BYTE     bErrorReplacementChar;  /*  Error Replacement Character. */
     56  BYTE     bBreakReplacementChar;  /*  Break Replacement Character. */
     57  BYTE     bXONChar;               /*  Character XON. */
     58  BYTE     bXOFFChar;              /*  Character XOFF. */
     59} DCBINFO;
     60typedef DCBINFO *PDCBINFO;
     61
     62
     63typedef struct _RXQUEUE
     64{
     65  USHORT   cch;  /*  Number of characters in the queue. */
     66  USHORT   cb;   /*  Size of receive/transmit queue. */
     67} RXQUEUE;
     68
     69typedef RXQUEUE *PRXQUEUE;
     70
     71
     72typedef struct _MODEMSTATUS
     73{
     74  BYTE   fbModemOn;   /*  Modem Control Signals ON Mask. */
     75  BYTE   fbModemOff;  /*  Modem Control Signals OFF Mask. */
     76} MODEMSTATUS;
     77
     78typedef MODEMSTATUS *PMODEMSTATUS;
     79
     80
     81#pragma pack()
     82
     83
     84
     85
     86
     87typedef struct _HMDEVCOMDATA
     88{
     89  ULONG ulMagic;
     90  // Win32 Device Control Block
     91  COMMCONFIG   CommCfg;
     92  COMMTIMEOUTS CommTOuts;
     93  DWORD dwInBuffer, dwOutBuffer;
     94  DWORD dwEventMask;
     95  //OS/2 Device Control Block
     96  DCBINFO dcbOS2;
     97} HMDEVCOMDATA, *PHMDEVCOMDATA;
     98
     99VOID * CreateDevData()
     100{
     101  PHMDEVCOMDATA pData;
     102  pData = new HMDEVCOMDATA();
     103  if(NULL!=pData)
     104  {
     105    memset(pData,0,sizeof(HMDEVCOMDATA));
     106    pData->ulMagic = MAGIC_COM;
     107    pData->CommCfg.dwSize   = sizeof(COMMCONFIG);
     108    pData->CommCfg.wVersion = 1;
     109    pData->CommCfg.dwProviderSubType = PST_RS232;
     110    pData->CommCfg.dcb.DCBlength = sizeof(DCB);
     111    pData->CommCfg.dcb.BaudRate  = CBR_1200;
     112    pData->CommCfg.dcb.ByteSize = 8;
     113    pData->CommCfg.dcb.Parity   = NOPARITY;
     114    pData->CommCfg.dcb.StopBits = ONESTOPBIT;
     115    pData->dwInBuffer  = 16;
     116    pData->dwOutBuffer = 16;
     117  }
     118  return pData;
     119}
    23120
    24121HMDeviceCommClass::HMDeviceCommClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName)
    25122{
    26   dprintf(("HMDeviceCommClass: Register COM1 to COM4 with Handle Manager\n"));
    27   HMDeviceRegister("COM1", this);
    28   HMDeviceRegister("COM2", this);
    29   HMDeviceRegister("COM3", this);
    30   HMDeviceRegister("COM4", this);
    31   HMDeviceRegister("COM5", this);
    32   HMDeviceRegister("COM6", this);
    33   HMDeviceRegister("COM7", this);
    34   HMDeviceRegister("COM8", this);
    35 }
    36 
    37 
     123  VOID *pData;
     124  dprintf(("HMDeviceCommClass: Register COM1 to COM8 with Handle Manager\n"));
     125  pData = CreateDevData();
     126  if(pData!= NULL)
     127    HMDeviceRegisterEx("COM1", this, pData);
     128  pData = CreateDevData();
     129  if(pData!= NULL)
     130    HMDeviceRegisterEx("COM2", this, pData);
     131  pData = CreateDevData();
     132  if(pData!= NULL)
     133    HMDeviceRegisterEx("COM3", this, pData);
     134  pData = CreateDevData();
     135  if(pData!= NULL)
     136    HMDeviceRegisterEx("COM4", this, pData);
     137  pData = CreateDevData();
     138  if(pData!= NULL)
     139    HMDeviceRegisterEx("COM5", this, pData);
     140  pData = CreateDevData();
     141  if(pData!= NULL)
     142    HMDeviceRegisterEx("COM6", this, pData);
     143  pData = CreateDevData();
     144  if(pData!= NULL)
     145    HMDeviceRegisterEx("COM7", this, pData);
     146  pData = CreateDevData();
     147  if(pData!= NULL)
     148    HMDeviceRegisterEx("COM8", this, pData);
     149}
    38150
    39151DWORD HMDeviceCommClass::CreateFile(LPCSTR lpFileName,
    … …  
    46158  pHMHandleData->hHMHandle = 0;
    47159
    48   //AH: TODO parse Win32 security handles   
     160  //AH: TODO parse Win32 security handles
    49161  OSLibDosDisableHardError(TRUE);
    50162  pHMHandleData->hHMHandle = OSLibDosOpen((char*)lpFileName,
    … …  
    54166  OSLibDosDisableHardError(FALSE);
    55167  if (pHMHandleData->hHMHandle != 0)
     168  {
     169    ULONG ulLen;
     170    APIRET rc;
     171
     172    pHMHandleData->lpHandlerData = new HMDEVCOMDATA();
     173    // Init The handle instance with the default default device config
     174    memcpy( pHMHandleData->lpHandlerData,
     175            pHMHandleData->lpDeviceData,
     176            sizeof(HMDEVCOMDATA));
     177
     178    ulLen = sizeof(DCBINFO);
     179
     180    rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     181                      IOCTL_ASYNC,
     182                      ASYNC_GETDCBINFO,
     183                      0,0,0,
     184                      &((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2,ulLen,&ulLen);
     185
     186    if(!rc)
     187    {
     188      return -1;
     189    }
    56190    return 0;
     191  }
    57192  else
    58193    return  -1;
    … …  
    64199{
    65200  dprintf(("HMComm: Serial communication port close request\n"));
     201  delete pHMHandleData->lpHandlerData;
    66202  return OSLibDosClose(pHMHandleData->hHMHandle);
    67203}
    68204
    69205/*****************************************************************************
    70  * Name      : DWORD HMDeviceHandler::SetupComm     
     206 * Name      : DWORD HMDeviceHandler::SetupComm
    71207 * Purpose   : set com port parameters (queue)
    72208 * Variables :
    73  * Result    : 
     209 * Result    :
    74210 * Remark    :
    75211 * Status    :
    … …  
    78214 *****************************************************************************/
    79215
    80 BOOL HMDeviceCommClass::SetupComm(PHMHANDLEDATA pHMHandleData, DWORD dwInQueue, DWORD dwOutQueue)
    81 {
    82   dprintf(("HMDeviceCommClass::SetupComm unimplemented stub!"));
    83 
    84 
    85   return(TRUE);
    86 }
     216BOOL HMDeviceCommClass::SetupComm( PHMHANDLEDATA pHMHandleData,
     217                                   DWORD dwInQueue,
     218                                   DWORD dwOutQueue)
     219{
     220  dprintf(("HMDeviceCommClass::SetupComm "));
     221  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     222  if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
     223  {
     224    O32_SetLastError(ERROR_INVALID_HANDLE);
     225    return FALSE;
     226  }
     227  pDevData->dwInBuffer  = dwInQueue;
     228  pDevData->dwOutBuffer = dwOutQueue;
     229
     230  return(TRUE);
     231}
     232
     233BOOL HMDeviceCommClass::WaitCommEvent( PHMHANDLEDATA pHMHandleData,
     234                                       LPDWORD lpfdwEvtMask,
     235                                       LPOVERLAPPED lpo)
     236{
     237  APIRET rc;
     238  ULONG ulLen;
     239  USHORT COMEvt;
     240  DWORD dwEvent,dwMask;
     241
     242  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     243
     244  dprintf(("HMDeviceCommClass::WaitCommEvent"));
     245  ulLen = sizeof(CHAR);
     246
     247  dwEvent = 0;
     248  rc = 0;
     249  ulLen = sizeof(COMEvt);
     250  dwMask = pDevData->dwEventMask;
     251  while( (0==rc) &&
     252        !(dwEvent & dwMask) &&
     253        (dwMask ==pDevData->dwEventMask) ) // Exit if the Mask gets changed
     254  {
     255    rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     256                      IOCTL_ASYNC,
     257                      ASYNC_GETCOMMEVENT,
     258                      0,0,0,
     259                      &COMEvt,ulLen,&ulLen);
     260    if(!rc)
     261    {
     262      dwEvent |= (COMEvt&0x0001)? EV_RXCHAR:0;
     263      //dwEvent |= (COMEvt&0x0002)? 0:0;
     264      dwEvent |= (COMEvt&0x0004)? EV_TXEMPTY:0;
     265      dwEvent |= (COMEvt&0x0008)? EV_CTS:0;
     266      dwEvent |= (COMEvt&0x0010)? EV_DSR:0;
     267      //dwEvent |= (COMEvt&0x0020)? 0:0; DCS = RLSD?
     268      dwEvent |= (COMEvt&0x0040)? EV_BREAK:0;
     269      dwEvent |= (COMEvt&0x0080)? EV_ERR:0;
     270      dwEvent |= (COMEvt&0x0100)? EV_RING:0;
     271    }
     272    DosSleep(100);
     273  }
     274  *lpfdwEvtMask = rc==0?dwEvent:0;
     275  return(rc==0);
     276}
     277
     278
     279#pragma pack(1)
     280typedef struct
     281{
     282  ULONG ulCurrBaud;
     283  UCHAR ucCurrFrac;
     284  ULONG ulMinBaud;
     285  UCHAR ucMinFrac;
     286  ULONG ulMaxBaud;
     287  UCHAR ucMaxFrac;
     288} EXTBAUDGET, *PEXTBAUDGET;
     289
     290typedef struct
     291{
     292  ULONG ulBaud;
     293  UCHAR ucFrac;
     294} EXTBAUDSET, *PEXTBAUDSET;
     295#pragma pack()
     296
     297BAUDTABLEENTRY BaudTable[] =
     298{
     299  {75,BAUD_075},
     300  {110,BAUD_110},
     301  {134,BAUD_134_5},
     302  {150,BAUD_150},
     303  {300,BAUD_300},
     304  {600,BAUD_600},
     305  {1200,BAUD_1200},
     306  {1800,BAUD_1800},
     307  {2400,BAUD_2400},
     308  {4800,BAUD_4800},
     309  {7200,BAUD_7200},
     310  {9600,BAUD_9600},
     311  {14400,BAUD_14400},
     312  {19200,BAUD_19200},
     313  {38400,BAUD_38400},
     314  {56000,BAUD_56K},
     315  {57600,BAUD_57600},
     316  {115200,BAUD_115200},
     317  {128000,BAUD_128K}
     318};
     319
     320#define BaudTableSize (sizeof(BaudTable)/sizeof(BAUDTABLEENTRY))
     321
     322BOOL HMDeviceCommClass::GetCommProperties( PHMHANDLEDATA pHMHandleData,
     323                                           LPCOMMPROP lpcmmp)
     324{
     325  EXTBAUDGET BaudInfo;
     326  APIRET rc;
     327  ULONG ulLen;
     328  USHORT COMErr;
     329  int i;
     330  dprintf(("HMDeviceCommClass::GetCommProperties"));
     331
     332  ulLen = sizeof(EXTBAUDGET);
     333  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     334                    IOCTL_ASYNC,
     335                    ASYNC_EXTGETBAUDRATE,
     336                    0,0,0,
     337                    &BaudInfo,ulLen,&ulLen);
     338  memset(lpcmmp,0,sizeof(COMMPROP));
     339  lpcmmp->wPacketLength  = sizeof(COMMPROP);
     340  lpcmmp->wPacketVersion = 1; //???
     341  lpcmmp->dwServiceMask  = SP_SERIALCOMM;
     342  for(i=0;i<BaudTableSize && BaudInfo.ulMaxBaud <= BaudTable[i].dwBaudRate;i++);
     343  lpcmmp->dwMaxBaud      = BaudTable[i].dwBaudFlag;
     344  lpcmmp->dwProvSubType =  PST_RS232;
     345  lpcmmp->dwProvCapabilities = PCF_DTRDSR | PCF_PARITY_CHECK |
     346                               PCF_RTSCTS | PCF_SETXCHAR |
     347                               PCF_XONXOFF;
     348  lpcmmp->dwSettableParams   = SP_BAUD | SP_DATABITS |
     349                               SP_HANDSHAKEING | SP_PARITY |
     350                               SP_PARITY_CHECK | SP_STOPBIT;
     351  lpcmmp->dwSettableBaud = 0;
     352  for(i=0;i<BaudTableSize;i++)
     353  {
     354    if ( (BaudTable[i].dwBaudRate>=BaudInfo.ulMinBaud) &&
     355         (BaudTable[i].dwBaudRate<=BaudInfo.ulMaxBaud) )
     356      lpcmmp->dwSettableBaud |= BaudTable[i].dwBaudFlag;
     357  }
     358  lpcmmp->dwSettableBaud |= BAUD_USER;
     359  lpcmmp->wSettableData = DATABITS_5 | DATABITS_6 | DATABITS_7 | DATABITS_8;
     360  lpcmmp->wSettableStopParity = STOPBITS_10 | STOPBITS_15 | STOPBITS_20 |
     361                                PARITY_NONE | PARITY_ODD | PARITY_EVEN |
     362                                PARITY_MARK | PARITY_SPACE;
     363  return(rc==0);
     364}
     365
     366BOOL HMDeviceCommClass::GetCommMask( PHMHANDLEDATA pHMHandleData,
     367                                     LPDWORD lpfdwEvtMask)
     368{
     369  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     370
     371  dprintf(("HMDeviceCommClass::GetCommMask"));
     372
     373  *lpfdwEvtMask = pDevData->dwEventMask;
     374  return(TRUE);
     375}
     376
     377BOOL HMDeviceCommClass::SetCommMask( PHMHANDLEDATA pHMHandleData,
     378                                     DWORD fdwEvtMask)
     379{
     380  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     381  dprintf(("HMDeviceCommClass::SetCommMask"));
     382
     383  pDevData->dwEventMask = fdwEvtMask & ~(EV_RLSD|EV_RXFLAG); // Clear the 2 not supported Flags.
     384  return(TRUE);
     385}
     386
     387BOOL HMDeviceCommClass::PurgeComm( PHMHANDLEDATA pHMHandleData,
     388                                   DWORD fdwAction)
     389{
     390  dprintf(("HMDeviceCommClass::PurgeComm unimplemented stub!"));
     391  // ToDo: find a way to stop the current transmision didn't find
     392  // any clue how to in Control Program Guide and reference
     393
     394  return(TRUE);
     395}
     396BOOL HMDeviceCommClass::ClearCommError( PHMHANDLEDATA pHMHandleData,
     397                                        LPDWORD lpdwErrors,
     398                                        LPCOMSTAT lpcst)
     399{
     400  APIRET rc;
     401  ULONG ulLen;
     402  USHORT COMErr;
     403
     404  dprintf(("HMDeviceCommClass::ClearCommError"));
     405  ulLen = sizeof(USHORT);
     406
     407  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     408                    IOCTL_ASYNC,
     409                    ASYNC_GETCOMMERROR,
     410                    0,0,0,
     411                    &COMErr,2,&ulLen);
     412  *lpdwErrors = 0;
     413  *lpdwErrors |= (COMErr & 0x0001)?CE_OVERRUN:0;
     414  *lpdwErrors |= (COMErr & 0x0002)?CE_RXOVER:0;
     415  *lpdwErrors |= (COMErr & 0x0004)?CE_RXPARITY:0;
     416  *lpdwErrors |= (COMErr & 0x0008)?CE_FRAME:0;
     417
     418  if(lpcst)
     419  {
     420    UCHAR ucStatus;
     421    RXQUEUE qInfo;
     422    ulLen = 1;
     423    rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     424                      IOCTL_ASYNC,
     425                      ASYNC_GETCOMMSTATUS,
     426                      0,0,0,
     427                      &ucStatus,ulLen,&ulLen);
     428    if(!rc)
     429    {
     430      lpcst->fCtsHold  = ((ucStatus & 0x01)>0);
     431      lpcst->fDsrHold  = ((ucStatus & 0x02)>0);
     432      lpcst->fRlsdHold = FALSE;//(ucStatus & 0x04)>0);
     433      lpcst->fXoffHold = ((ucStatus & 0x08)>0);
     434      lpcst->fXoffSend = ((ucStatus & 0x10)>0);
     435      lpcst->fEof      = ((ucStatus & 0x20)>0);// Is break = Eof ??
     436      lpcst->fTxim     = ((ucStatus & 0x40)>0);
     437
     438      ulLen = sizeof(qInfo);
     439      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     440                        IOCTL_ASYNC,
     441                        ASYNC_GETINQUECOUNT,
     442                        0,0,0,
     443                        &qInfo,ulLen,&ulLen);
     444      if(!rc)
     445      {
     446        lpcst->cbInQue   = qInfo.cch;
     447        rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     448                          IOCTL_ASYNC,
     449                          ASYNC_GETOUTQUECOUNT,
     450                          0,0,0,
     451                          &qInfo,ulLen,&ulLen);
     452        if(!rc)
     453          lpcst->cbOutQue = qInfo.cch;
     454      }
     455    }
     456  }
     457
     458  return(rc==0);
     459}
     460BOOL HMDeviceCommClass::SetCommState( PHMHANDLEDATA pHMHandleData,
     461                                      LPDCB lpDCB)
     462{
     463  APIRET rc;
     464  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     465  DCB *pCurDCB = &pDevData->CommCfg.dcb;
     466  dprintf(("HMDeviceCommClass::SetCommState"));
     467
     468  rc = 0;
     469  if(pCurDCB->BaudRate != lpDCB->BaudRate)
     470    rc = SetBaud( pHMHandleData,
     471                  lpDCB->BaudRate);
     472
     473  if(!rc)
     474  {
     475    if( (pCurDCB->ByteSize != lpDCB->ByteSize) ||
     476        (pCurDCB->Parity   != lpDCB->Parity) ||
     477        (pCurDCB->StopBits != lpDCB->StopBits))
     478      rc = SetLine( pHMHandleData,
     479                    lpDCB->ByteSize,
     480                    lpDCB->Parity,
     481                    lpDCB->StopBits);
     482  }
     483
     484  if(!rc)
     485  {
     486    if( (pCurDCB->fOutxCtsFlow       != lpDCB->fOutxCtsFlow) ||
     487        (pCurDCB->fOutxDsrFlow       != lpDCB->fOutxDsrFlow) ||
     488        (pCurDCB->fDtrControl        != lpDCB->fDtrControl) ||
     489        (pCurDCB->fDsrSensitivity    != lpDCB->fDsrSensitivity) ||
     490        (pCurDCB->fTXContinueOnXoff  != lpDCB->fTXContinueOnXoff) ||
     491        (pCurDCB->fOutX              != lpDCB->fOutX) ||
     492        (pCurDCB->fInX               != lpDCB->fInX) ||
     493        (pCurDCB->fErrorChar         != lpDCB->fErrorChar) ||
     494        (pCurDCB->fNull              != lpDCB->fNull) ||
     495        (pCurDCB->fRtsControl        != lpDCB->fRtsControl) ||
     496        (pCurDCB->fAbortOnError      != lpDCB->fAbortOnError) ||
     497        (pCurDCB->XonChar            != lpDCB->XonChar) ||
     498        (pCurDCB->XoffChar           != lpDCB->XoffChar) ||
     499        (pCurDCB->ErrorChar          != lpDCB->ErrorChar))
     500      SetOS2DCB( pHMHandleData,
     501                 lpDCB->fOutxCtsFlow, lpDCB->fOutxDsrFlow,
     502                 lpDCB->fDtrControl,  lpDCB->fDsrSensitivity,
     503                 lpDCB->fTXContinueOnXoff, lpDCB->fOutX,
     504                 lpDCB->fInX, lpDCB->fErrorChar,
     505                 lpDCB->fNull, lpDCB->fRtsControl,
     506                 lpDCB->fAbortOnError, lpDCB->XonChar,
     507                 lpDCB->XoffChar,lpDCB->ErrorChar);
     508  }
     509
     510  return(rc==0);
     511}
     512BOOL HMDeviceCommClass::GetCommState( PHMHANDLEDATA pHMHandleData,
     513                                      LPDCB lpdcb)
     514{
     515  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     516
     517  dprintf(("HMDeviceCommClass::GetCommState"));
     518  memcpy(lpdcb,&pDevData->CommCfg.dcb,sizeof(DCB));
     519
     520  return(TRUE);
     521}
     522BOOL HMDeviceCommClass::GetCommModemStatus( PHMHANDLEDATA pHMHandleData,
     523                                          LPDWORD lpModemStat )
     524{
     525  APIRET rc;
     526  ULONG ulLen;
     527  USHORT COMErr;
     528  UCHAR ucStatus;
     529
     530  dprintf(("HMDeviceCommClass::TransmitCommChar partly implemented"));
     531  ulLen = sizeof(CHAR);
     532
     533  ulLen = 1;
     534  *lpModemStat = 0;
     535
     536  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     537                    IOCTL_ASYNC,
     538                    ASYNC_GETMODEMINPUT,
     539                    0,0,0,
     540                    &ucStatus,ulLen,&ulLen);
     541  if(!rc)
     542  {
     543    *lpModemStat |= (ucStatus & 0x10)? MS_CTS_ON:0;
     544    *lpModemStat |= (ucStatus & 0x20)? MS_DSR_ON:0;
     545    *lpModemStat |= (ucStatus & 0x40)? MS_RING_ON:0;
     546    //*lpModemStat |= (ucStatus & 0x80)? MS_RSLD_ON:0;
     547  }
     548
     549  return(rc==0);
     550}
     551
     552BOOL HMDeviceCommClass::GetCommTimeouts( PHMHANDLEDATA pHMHandleData,
     553                                         LPCOMMTIMEOUTS lpctmo)
     554{
     555  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     556
     557  dprintf(("HMDeviceCommClass::GetCommTimeouts stub"));
     558  memcpy( lpctmo,
     559          &pDevData->CommTOuts,
     560          sizeof(COMMTIMEOUTS));
     561  return(TRUE);
     562}
     563BOOL HMDeviceCommClass::SetCommTimeouts( PHMHANDLEDATA pHMHandleData,
     564                                         LPCOMMTIMEOUTS lpctmo)
     565{
     566  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     567  DCBINFO os2dcb;
     568  ULONG ulLen;
     569  APIRET rc;
     570
     571  memcpy( &pDevData->CommTOuts,
     572          lpctmo,
     573          sizeof(COMMTIMEOUTS));
     574
     575  memcpy(&os2dcb,&pDevData->dcbOS2,sizeof(DCBINFO));
     576
     577  os2dcb.fbTimeOut = 0x01;
     578  if(MAXDWORD==pDevData->CommTOuts.ReadIntervalTimeout)
     579  {
     580    if( (0==pDevData->CommTOuts.ReadTotalTimeoutMultiplier) &&
     581        (0==pDevData->CommTOuts.ReadTotalTimeoutConstant))
     582      os2dcb.fbTimeOut = 0x03;
     583    else
     584      os2dcb.fbTimeOut = 0x02;
     585  }
     586  else
     587  {
     588    DWORD dwTimeout;
     589    dwTimeout = pDevData->CommTOuts.ReadIntervalTimeout/10;
     590    if(dwTimeout)
     591      dwTimeout--; // 0=10 ms unit is 10ms or .01s
     592    os2dcb.usWriteTimeout = 0x0000FFFF & dwTimeout;
     593    os2dcb.usReadTimeout  = 0x0000FFFF & dwTimeout;
     594  }
     595  ulLen = sizeof(DCBINFO);
     596  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     597                          IOCTL_ASYNC,
     598                          ASYNC_SETDCBINFO,
     599                          &os2dcb,ulLen,&ulLen,
     600                          NULL,0,NULL);
     601
     602  return(0==rc);
     603}
     604BOOL HMDeviceCommClass::TransmitCommChar( PHMHANDLEDATA pHMHandleData,
     605                                          CHAR cChar )
     606{
     607  APIRET rc;
     608  ULONG ulLen;
     609  USHORT COMErr;
     610
     611  dprintf(("HMDeviceCommClass::TransmitCommChar"));
     612  ulLen = sizeof(CHAR);
     613
     614  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     615                    IOCTL_ASYNC,
     616                    ASYNC_TRANSMITIMM,
     617                    &cChar,ulLen,&ulLen,
     618                    NULL,0,NULL);
     619
     620  return(rc==0);
     621}
     622
     623BOOL HMDeviceCommClass::SetCommBreak( PHMHANDLEDATA pHMHandleData )
     624{
     625  APIRET rc;
     626  ULONG ulLen;
     627  USHORT COMErr;
     628
     629  dprintf(("HMDeviceCommClass::SetCommBreak"));
     630  ulLen = sizeof(USHORT);
     631
     632  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     633                    IOCTL_ASYNC,
     634                    ASYNC_SETBREAKON,
     635                    0,0,0,
     636                    &COMErr,2,&ulLen);
     637
     638  return(rc==0);
     639}
     640
     641BOOL HMDeviceCommClass::ClearCommBreak( PHMHANDLEDATA pHMHandleData)
     642{
     643  APIRET rc;
     644  ULONG ulLen;
     645  USHORT COMErr;
     646
     647  dprintf(("HMDeviceCommClass::ClearCommBreak"));
     648  ulLen = sizeof(USHORT);
     649
     650  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     651                    IOCTL_ASYNC,
     652                    ASYNC_SETBREAKOFF,
     653                    0,0,0,
     654                    &COMErr,2,&ulLen);
     655
     656  return(rc==0);
     657}
     658
     659BOOL HMDeviceCommClass::SetCommConfig( PHMHANDLEDATA pHMHandleData,
     660                                       LPCOMMCONFIG lpCC,
     661                                       DWORD dwSize )
     662{
     663  dprintf(("HMDeviceCommClass::SetCommConfig"));
     664
     665
     666  return(TRUE);
     667}
     668
     669BOOL HMDeviceCommClass::GetCommConfig( PHMHANDLEDATA pHMHandleData,
     670                                       LPCOMMCONFIG lpCC,
     671                                       LPDWORD lpdwSize )
     672{
     673  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     674
     675  dprintf(("HMDeviceCommClass::GetCommConfig"));
     676
     677  if( O32_IsBadWritePtr(lpCC,sizeof(COMMCONFIG)) ||
     678      *lpdwSize< sizeof(COMMCONFIG) )
     679  {
     680    O32_SetLastError(ERROR_INSUFFICIENT_BUFFER);
     681    *lpdwSize= sizeof(COMMCONFIG);
     682    return FALSE;
     683  }
     684
     685  if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
     686  {
     687    O32_SetLastError(ERROR_INVALID_HANDLE);
     688    return FALSE;
     689  }
     690
     691  memcpy(lpCC,&pDevData->CommCfg,sizeof(COMMCONFIG));
     692  *lpdwSize = sizeof(COMMCONFIG);
     693  return(TRUE);
     694
     695
     696  return(TRUE);
     697}
     698
     699BOOL HMDeviceCommClass::EscapeCommFunction( PHMHANDLEDATA pHMHandleData,
     700                                            UINT dwFunc )
     701{
     702  APIRET rc;
     703  ULONG ulDLen,ulPLen;
     704  USHORT COMErr;
     705  MODEMSTATUS mdm;
     706
     707  dprintf(("HMDeviceCommClass::EscapeCommFunction"));
     708
     709  ulDLen = sizeof(USHORT);
     710  ulPLen = sizeof(MODEMSTATUS);
     711  switch(dwFunc)
     712  {
     713    case CLRDTR:
     714      mdm.fbModemOn  = 0x00;
     715      mdm.fbModemOff = 0XFE;
     716      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     717                             IOCTL_ASYNC,
     718                             ASYNC_SETMODEMCTRL,
     719                             &mdm,ulPLen,&ulPLen,
     720                             &COMErr,ulDLen,&ulDLen);
     721      break;
     722    case CLRRTS:
     723      mdm.fbModemOn  = 0x00;
     724      mdm.fbModemOff = 0XFD;
     725      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     726                             IOCTL_ASYNC,
     727                             ASYNC_SETMODEMCTRL,
     728                             &mdm,ulPLen,&ulPLen,
     729                             &COMErr,ulDLen,&ulDLen);
     730      break;
     731    case SETDTR:
     732      mdm.fbModemOn  = 0x01;
     733      mdm.fbModemOff = 0XFF;
     734      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     735                             IOCTL_ASYNC,
     736                             ASYNC_SETMODEMCTRL,
     737                             &mdm,ulPLen,&ulPLen,
     738                             &COMErr,ulDLen,&ulDLen);
     739      break;
     740    case SETRTS:
     741      mdm.fbModemOn  = 0x02;
     742      mdm.fbModemOff = 0XFF;
     743      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     744                             IOCTL_ASYNC,
     745                             ASYNC_SETMODEMCTRL,
     746                             &mdm,ulPLen,&ulPLen,
     747                             &COMErr,ulDLen,&ulDLen);
     748      break;
     749    case SETXOFF:
     750      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     751                             IOCTL_ASYNC,
     752                             ASYNC_STOPTRANSMIT,
     753                             0,0,0,
     754                             0,0,0);
     755      break;
     756    case SETXON:
     757      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     758                             IOCTL_ASYNC,
     759                             ASYNC_STARTTRANSMIT,
     760                             0,0,0,
     761                             0,0,0);
     762      break;
     763    default:
     764      O32_SetLastError(ERROR_INVALID_PARAMETER);
     765      return(FALSE);
     766  }
     767
     768  return(rc==0);
     769}
     770
     771BOOL HMDeviceCommClass::SetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
     772                                              LPCOMMCONFIG lpCC,
     773                                              DWORD dwSize)
     774{
     775  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpDeviceData;
     776  if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
     777  {
     778    O32_SetLastError(ERROR_INVALID_HANDLE);
     779    return FALSE;
     780  }
     781  memset(&pDevData->CommCfg,0, sizeof(COMMCONFIG));
     782  memcpy(&pDevData->CommCfg,lpCC,dwSize>sizeof(COMMCONFIG)?sizeof(COMMCONFIG):dwSize);
     783
     784  return(TRUE);
     785}
     786BOOL HMDeviceCommClass::GetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
     787                                              LPCOMMCONFIG lpCC,
     788                                              LPDWORD lpdwSize)
     789{
     790  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpDeviceData;
     791
     792  if( O32_IsBadWritePtr(lpCC,sizeof(COMMCONFIG)) ||
     793      *lpdwSize< sizeof(COMMCONFIG) )
     794  {
     795    O32_SetLastError(ERROR_INSUFFICIENT_BUFFER);
     796    *lpdwSize= sizeof(COMMCONFIG);
     797    return FALSE;
     798  }
     799
     800  if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
     801  {
     802    O32_SetLastError(ERROR_INVALID_HANDLE);
     803    return FALSE;
     804  }
     805
     806  memcpy(lpCC,&pDevData->CommCfg,sizeof(COMMCONFIG));
     807  *lpdwSize = sizeof(COMMCONFIG);
     808  return(TRUE);
     809}
     810APIRET HMDeviceCommClass::SetLine( PHMHANDLEDATA pHMHandleData,
     811                                   UCHAR ucSize,
     812                                   UCHAR ucParity,
     813                                   UCHAR ucStop)
     814{
     815  APIRET rc;
     816  ULONG ulLen;
     817  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     818  DCB *pCurDCB = &pDevData->CommCfg.dcb;
     819  struct
     820  {
     821    UCHAR ucSize;
     822    UCHAR ucParity;
     823    UCHAR ucStop;
     824    UCHAR ucPadding;
     825  }Param;
     826
     827  ulLen = 3;
     828  Param.ucSize   = ucSize;
     829  Param.ucParity = ucParity;
     830  Param.ucStop   = ucStop;
     831
     832  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     833                    IOCTL_ASYNC,
     834                    ASYNC_SETLINECTRL,
     835                    &Param,ulLen,&ulLen,
     836                    NULL,0,NULL);
     837
     838  if(0==rc)
     839  {
     840    pCurDCB->ByteSize = ucSize;
     841    pCurDCB->Parity   = ucParity;
     842    pCurDCB->StopBits = ucStop;
     843  }
     844
     845  return rc;
     846}
     847
     848APIRET HMDeviceCommClass::SetOS2DCB( PHMHANDLEDATA pHMHandleData,
     849                                     BOOL fOutxCtsFlow, BOOL fOutxDsrFlow,
     850                                     UCHAR ucDtrControl,  BOOL fDsrSensitivity,
     851                                     BOOL fTXContinueOnXoff, BOOL fOutX,
     852                                     BOOL fInX, BOOL fErrorChar,
     853                                     BOOL fNull, UCHAR ucRtsControl,
     854                                     BOOL fAbortOnError, BYTE XonChar,
     855                                     BYTE XoffChar,BYTE ErrorChar)
     856{
     857  APIRET rc;
     858  ULONG ulLen;
     859  DCBINFO os2dcb;
     860
     861  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     862  DCB *pCurDCB = &pDevData->CommCfg.dcb;
     863
     864  memcpy(&os2dcb,&pDevData->dcbOS2,sizeof(DCBINFO));
     865  os2dcb.fbCtlHndShake = (ucDtrControl & 0x03) |
     866                         (fOutxCtsFlow?0x08:0x00) |
     867                         (fOutxDsrFlow?0x10:0x00) |
     868                         // No DCD support in Win32 ?!
     869                         (fDsrSensitivity?0x40:0x00);
     870  os2dcb.fbFlowReplace = (fOutX?0x01:0x00) |
     871                         (fInX?0x02:0x00) |
     872                         (fErrorChar?0x04:0x00)|
     873                         (fNull?0x08:0x00)|
     874                         (fTXContinueOnXoff?0x02:0x00)| // Not sure if thats the right flag to test
     875                         (ucRtsControl<<6);
     876
     877  os2dcb.fbTimeOut = 0x01;
     878  if(MAXDWORD==pDevData->CommTOuts.ReadIntervalTimeout)
     879  {
     880    if( (0==pDevData->CommTOuts.ReadTotalTimeoutMultiplier) &&
     881        (0==pDevData->CommTOuts.ReadTotalTimeoutConstant))
     882      os2dcb.fbTimeOut = 0x03;
     883    else
     884      os2dcb.fbTimeOut = 0x02;
     885  }
     886  else
     887  {
     888    DWORD dwTimeout;
     889    dwTimeout = pDevData->CommTOuts.ReadIntervalTimeout/10;
     890    if(dwTimeout)
     891      dwTimeout--; // 0=10 ms unit is 10ms or .01s
     892    os2dcb.usWriteTimeout = 0x0000FFFF & dwTimeout;
     893    os2dcb.usReadTimeout  = 0x0000FFFF & dwTimeout;
     894  }
     895  os2dcb.bErrorReplacementChar = ErrorChar;
     896  os2dcb.bXONChar              = XonChar;
     897  os2dcb.bXOFFChar             = XoffChar;
     898  ulLen = sizeof(DCBINFO);
     899  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     900                          IOCTL_ASYNC,
     901                          ASYNC_SETDCBINFO,
     902                          &os2dcb,ulLen,&ulLen,
     903                          NULL,0,NULL);
     904
     905  if(0==rc)
     906  {
     907    memcpy(&pDevData->dcbOS2,&os2dcb,sizeof(DCBINFO));
     908    pCurDCB->fOutxCtsFlow       = fOutxCtsFlow;
     909    pCurDCB->fOutxDsrFlow       = fOutxDsrFlow;
     910    pCurDCB->fDtrControl        = ucDtrControl;
     911    pCurDCB->fDsrSensitivity    = fDsrSensitivity;
     912    pCurDCB->fTXContinueOnXoff  = fTXContinueOnXoff;
     913    pCurDCB->fOutX              = fOutX;
     914    pCurDCB->fInX               = fInX;
     915    pCurDCB->fErrorChar         = fErrorChar;
     916    pCurDCB->fNull              = fNull;
     917    pCurDCB->fRtsControl        = ucRtsControl;
     918    pCurDCB->fAbortOnError      = fAbortOnError;
     919    pCurDCB->XonChar            = XonChar;
     920    pCurDCB->XoffChar           = XoffChar;
     921    pCurDCB->ErrorChar          = ErrorChar;
     922  }
     923
     924  return rc;
     925
     926}
     927
     928APIRET HMDeviceCommClass::SetBaud( PHMHANDLEDATA pHMHandleData,
     929                                   DWORD dwNewBaud)
     930{
     931  APIRET rc;
     932  ULONG ulLen;
     933  EXTBAUDSET SetBaud;
     934  EXTBAUDGET GetBaud;
     935  ulLen = sizeof(SetBaud);
     936  SetBaud.ulBaud = dwNewBaud;
     937  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     938                    IOCTL_ASYNC,
     939                    ASYNC_EXTSETBAUDRATE,
     940                    &SetBaud,ulLen,&ulLen,
     941                    NULL,0,NULL);
     942  if(0==rc)
     943  {
     944    ulLen = sizeof(GetBaud);
     945    rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     946                      IOCTL_ASYNC,
     947                      ASYNC_EXTGETBAUDRATE,
     948                      NULL,0,NULL,
     949                      &GetBaud,ulLen,&ulLen);
     950    if(0==rc)
     951    {
     952      if(dwNewBaud !=GetBaud.ulCurrBaud)
     953        rc = 1; // ToDo set a proper Errorhandling
     954      else
     955      {
     956        ((PHMDEVCOMDATA)pHMHandleData->lpDeviceData)->CommCfg.dcb.BaudRate = dwNewBaud;
     957        ((PHMDEVCOMDATA)pHMHandleData->lpDeviceData)->CommCfg.dcb.BaudRate = dwNewBaud;
     958      }
     959    }
     960  }
     961  return rc;
     962}
     963
Note: See TracChangeset for help on using the changeset viewer.