ltmk.c

linux下1553B的开发

/*
void bcdefintnorm(void (* UserNormBC)(TMK_DATA, TMK_DATA, TMK_DATA));
void bcdefintexc(void (* UserExcBC)(TMK_DATA, TMK_DATA, TMK_DATA));
void bcdefintx(void (* UserXBC)(TMK_DATA, TMK_DATA));
void bcdefintsig(void (* UserSigBC)(TMK_DATA));
*/
int bcreset();
//void bc_def_tldw(TMK_DATA wTLDW);
//void bc_enable_di();
//void bc_disable_di();
int bcdefirqmode(TMK_DATA bcIrqMode);
TMK_DATA_RET bcgetirqmode();
TMK_DATA_RET bcgetmaxbase();
int bcdefbase(TMK_DATA bcBasePC);
TMK_DATA_RET bcgetbase();
void bcputw(TMK_DATA bcAddr, TMK_DATA bcData);
TMK_DATA_RET bcgetw(TMK_DATA bcAddr);
DWORD bcgetansw(TMK_DATA bcCtrlCode);
void bcputblk(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength);
void bcgetblk(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength);
int bcdefbus(TMK_DATA bcBus);
TMK_DATA_RET bcgetbus();
int bcstart(TMK_DATA bcBase, TMK_DATA bcCtrlCode);
int bcstartx(TMK_DATA bcBase, TMK_DATA bcCtrlCode);
int bcdeflink(TMK_DATA bcBase, TMK_DATA bcCtrlCode);
DWORD bcgetlink();
TMK_DATA_RET bcstop();
DWORD bcgetstate();

/*
void rtdefintcmd(void (* UserCmdRT)(TMK_DATA));
void rtdefinterr(void (* UserErrRT)(TMK_DATA));
void rtdefintdata(void (* UserDataRT)(TMK_DATA));
*/
int rtreset();
int rtdefirqmode(TMK_DATA rtIrqMode);
TMK_DATA_RET rtgetirqmode();
int rtdefmode(TMK_DATA rtMode);
TMK_DATA_RET rtgetmode();
TMK_DATA_RET rtgetmaxpage();
int rtdefpage(TMK_DATA rtPage);
TMK_DATA_RET rtgetpage();
int rtdefpagepc(TMK_DATA rtPagePC);
int rtdefpagebus(TMK_DATA rtPageBus);
TMK_DATA_RET rtgetpagepc();
TMK_DATA_RET rtgetpagebus();
int rtdefaddress(TMK_DATA rtAddress);
TMK_DATA_RET rtgetaddress();
void rtdefsubaddr(TMK_DATA rtDir, TMK_DATA rtSubAddr);
TMK_DATA_RET rtgetsubaddr();
void rtputw(TMK_DATA rtAddr, TMK_DATA rtData);
TMK_DATA_RET rtgetw(TMK_DATA rtAddr);
void rtputblk(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength);
void rtgetblk(TMK_DATA rtAddr, void *pcBuffer, TMK_DATA cwLength);
void rtsetanswbits(TMK_DATA rtSetControl);
void rtclranswbits(TMK_DATA rtClrControl);
TMK_DATA_RET rtgetanswbits();
void rtgetflags(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax);
void rtputflags(void *pcBuffer, TMK_DATA rtDir, TMK_DATA rtFlagMin, TMK_DATA rtFlagMax);
void rtsetflag();
void rtclrflag();
TMK_DATA_RET rtgetflag(TMK_DATA rtDir, TMK_DATA rtSubAddr);
TMK_DATA_RET rtgetstate();
TMK_DATA_RET rtbusy();
void rtlock(TMK_DATA rtDir, TMK_DATA rtSubAddr);
void rtunlock();
TMK_DATA_RET rtgetcmddata(TMK_DATA rtBusCommand);
void rtputcmddata(TMK_DATA rtBusCommand, TMK_DATA rtData);

/*
void mtdefintx(void (* UserIntXMT)(TMK_DATA, TMK_DATA));
void mtdefintsig(void (* UserSigMT)(TMK_DATA));
*/
int mtreset();
#define mtdefirqmode bcdefirqmode
#define mtgetirqmode bcgetirqmode
#define mtgetmaxbase bcgetmaxbase
#define mtdefbase bcdefbase
#define mtgetbase bcgetbase
#define mtputw bcputw
#define mtgetw bcgetw
TMK_DATA_RET mtgetsw();
#define mtputblk bcputblk
#define mtgetblk bcgetblk
#define mtstartx bcstartx
#define mtdeflink bcdeflink
#define mtgetlink bcgetlink
#define mtstop bcstop
#define mtgetstate bcgetstate
TMK_DATA_RET rtenable(TMK_DATA rtEnable);
#ifdef _TMK1553B_MRT
int mrtgetmaxn();
DWORD mrtconfig(int tmkNumber);
int mrtselected();
TMK_DATA_RET mrtgetstate();
void mrtdefbrcsubaddr0();
int mrtreset();
#endif //def_TMK1553B_MRT

TMK_DATA_RET tmktimer(TMK_DATA tmkTimerCtrl);
DWORD tmkgettimer();
TMK_DATA_RET tmkgettimerl();
DWORD bcgetmsgtime();
#define mtgetmsgtime bcgetmsgtime
DWORD rtgetmsgtime();

TMK_DATA_RET tmkgethwver();

/*****************Functions***************************/

int TmkOpen()
{
  int _VTMK4Arg;
  int ErrorCode;
//  int iTMK;
#ifdef USE_TMK_ERROR
  tmkError = 0;
#endif  
  _hVTMK4VxD = open(
"/dev/tmk1553b",
 0);
  if (_hVTMK4VxD < 0)
  {
    ErrorCode = _hVTMK4VxD; //GetLastError();
/*
    if (ErrorCode == ERROR_NOT_SUPPORTED)
    {
      MessageBox(NULL,"Unable to open VxD,\ndevice does not support DeviceIOCTL",szTitle,MB_OK|MB_ICONSTOP);
    }
    else
    {
      sprintf(szPrintf,"Unable to open VxD, Error code: %lx", ErrorCode);
      MessageBox(NULL,szPrintf,szTitle,MB_OK|MB_ICONSTOP);
    }
*/
    _hVTMK4VxD = 0;
    return ErrorCode;
  }
/*
  for (iTMK = 0; iTMK <= MAX_TMK_NUMBER; ++iTMK)
    _ahVTMK4Event[iTMK] = 0;
*/
  if ((_VTMK4Arg = ioctl(_hVTMK4VxD, TMK_IOCGetVersion, 0)) < 0 ||
      _VTMK4Arg < TMK_VERSION_MIN)
  {
    close(_hVTMK4VxD);
    _hVTMK4VxD = 0;
    return VTMK_BAD_VERSION;
  }
  return 0;
}

void TmkClose()
{
#ifdef USE_TMK_ERROR
  tmkError = 0;
#endif  
  if (_hVTMK4VxD)
  {
    close(_hVTMK4VxD);
    _hVTMK4VxD = 0;
  }
}

int tmkgetmaxn()
{
#ifdef USE_TMK_ERROR
  tmkError = 0;
#endif  
  return (ioctl(_hVTMK4VxD, TMK_IOCtmkgetmaxn));
}

int tmkconfig(int tmkNumber)
{
//  _VTMK4tmkNumber = tmkNumber;
  return (
#ifdef USE_TMK_ERROR
    tmkError =
#endif
    ioctl(_hVTMK4VxD, TMK_IOCtmkconfig, tmkNumber));
  
}

int tmkdone(int tmkNumber)
{
/*
  int iTMK;
  if (tmkNumber == ALL_TMKS)
  {
    for (iTMK = 0; iTMK <= MAX_TMK_NUMBER; ++iTMK)
      _ahVTMK4Event[iTMK] = 0;
  }
  else if (tmkNumber >= 0 && tmkNumber <= MAX_TMK_NUMBER)
    _ahVTMK4Event[tmkNumber] = 0;
*/
  return (
#ifdef USE_TMK_ERROR
    tmkError = 
#endif
    ioctl(_hVTMK4VxD, TMK_IOCtmkdone, tmkNumber));
}

int tmkselect(int tmkNumber)
{
//  _VTMK4tmkNumber = tmkNumber;
  return (
#ifdef USE_TMK_ERROR
    tmkError  = 
#endif  
    ioctl(_hVTMK4VxD, TMK_IOCtmkselect, tmkNumber));
}

int tmkselected()
{
#ifdef USE_TMK_ERROR
  tmkError = 0;
#endif  
  return (
//  _VTMK4tmkNumber =
    ioctl(_hVTMK4VxD, TMK_IOCtmkselected));
}

TMK_DATA_RET tmkgetmode()
{
#ifdef USE_TMK_ERROR
  tmkError = 0;
#endif  
  return (ioctl(_hVTMK4VxD, TMK_IOCtmkgetmode));
}

void tmksetcwbits(TMK_DATA tmkSetControl)
{
#ifdef USE_TMK_ERROR
  tmkError = 
#endif  
  ioctl(_hVTMK4VxD, TMK_IOCtmksetcwbits, tmkSetControl);
}

void tmkclrcwbits(TMK_DATA tmkClrControl)
{
#ifdef USE_TMK_ERROR
  tmkError = 
#endif  
  ioctl(_hVTMK4VxD, TMK_IOCtmksetcwbits, tmkClrControl);
}

TMK_DATA_RET tmkgetcwbits()
{
#ifdef USE_TMK_ERROR
  tmkError = 0;
#endif  
  return (ioctl(_hVTMK4VxD, TMK_IOCtmkgetcwbits));
}

int tmkwaitevents(int maskEvents, int fWait)
{
  int _VTMK4Arg[2];
#ifdef USE_TMK_ERROR
  tmkError = 0;
#endif  
  _VTMK4Arg[0] = maskEvents;
  _VTMK4Arg[1] = fWait;
  return (ioctl(_hVTMK4VxD, TMK_IOCtmkwaitevents, &_VTMK4Arg));
}

/*
void tmkdefevent(HANDLE hEvent, BOOL fEventSet)
{
  WORD _awVTMK4InBuf[4], _awVTMK4OutBuf[1];
  int _VTMK4Arg;
  DWORD hVxDEvent;
  int iTMK;
  if (hEvent != 0)
  {
    for (iTMK = 0; iTMK <= MAX_TMK_NUMBER; ++iTMK)
    {
      if (hEvent == _ahVTMK4Event[iTMK])
        break;
    }
    if (iTMK > MAX_TMK_NUMBER)
    {
      hVxDEvent = (DWORD)hEvent;
      _ahVTMK4Event[_VTMK4tmkNumber] = hEvent;
    }
  }
  else
  {
    hVxDEvent = 0;
    _ahVTMK4Event[_VTMK4tmkNumber] = 0;
  }
  _awVTMK4InBuf[0] = LOWORD(hVxDEvent);
  _awVTMK4InBuf[1] = HIWORD(hVxDEvent);
  _awVTMK4InBuf[2] = LOWORD(fEventSet);
  _awVTMK4InBuf[3] = HIWORD(fEventSet);
  ioctl(_hVTMK4VxD, TMK_IOCtmkdefevent, _awVTMK4InBuf, 8, _awVTMK4OutBuf, 0, &_VTMK4Arg, NULL);
}
*/

void tmkgetevd(TTmkEventData *pEvD)
{
  WORD _awVTMK4OutBuf[6];
//  int _VTMK4Arg;
#ifdef USE_TMK_ERROR
  tmkError = 
#endif  
  ioctl(_hVTMK4VxD, TMK_IOCtmkgetevd, _awVTMK4OutBuf);
  pEvD->nInt = ((DWORD*)(_awVTMK4OutBuf))[0];
  switch (pEvD->wMode = _awVTMK4OutBuf[2])
  {
  case BC_MODE:
    switch (pEvD->nInt)
    {
    case 1:
      pEvD->bc.wResult = _awVTMK4OutBuf[3];
      break;
    case 2:
      pEvD->bc.wResult = _awVTMK4OutBuf[3];
      pEvD->bc.wAW1 = _awVTMK4OutBuf[4];
      pEvD->bc.wAW2 = _awVTMK4OutBuf[5];
      break;
    case 3:
      pEvD->bcx.wResultX = _awVTMK4OutBuf[3];
      pEvD->bcx.wBase = _awVTMK4OutBuf[4];
      break;
    case 4:
      pEvD->bcx.wBase = _awVTMK4OutBuf[3];
      break;
    }
    break;
  case MT_MODE:
    switch (pEvD->nInt)
    {
    case 3:
      pEvD->mt.wResultX = _awVTMK4OutBuf[3];
      pEvD->mt.wBase = _awVTMK4OutBuf[4];
      break;
    case 4:
      pEvD->mt.wBase = _awVTMK4OutBuf[3];
      break;
    }
    break;
  case RT_MODE:
    switch (pEvD->nInt)
    {
    case 1:
      pEvD->rt.wCmd = _awVTMK4OutBuf[3];
      break;
    case 2:
    case 3:
      pEvD->rt.wStatus = _awVTMK4OutBuf[3];
      break;
    }
    break;
  case MRT_MODE:
    pEvD->mrt.wStatus = _awVTMK4OutBuf[3];
    break;
  }
}
void tmkgetinfo(TTmkConfigData *pConfD)
{
#ifdef USE_TMK_ERROR
  tmkError = 
#endif  
  ioctl(_hVTMK4VxD, TMK_IOCtmkgetinfo, pConfD);
}

/*
void bcdefintnorm(void (* UserNormBC)(TMK_DATA, TMK_DATA, TMK_DATA))
{
  ;
//  ioctl(_hVTMK4VxD, TMK_IOCbcdefintnorm, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_VTMK4Arg, NULL);
}
void bcdefintexc(void (* UserExcBC)(TMK_DATA, TMK_DATA, TMK_DATA))
{
  ;
//  ioctl(_hVTMK4VxD, TMK_IOCbcdefintexc, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_VTMK4Arg, NULL);
}
void bcdefintx(void (* UserXBC)(TMK_DATA, TMK_DATA))
{
  ;
//  ioctl(_hVTMK4VxD, TMK_IOCbcdefintx, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_VTMK4Arg, NULL);
}
void bcdefintsig(void (* UserSigBC)(TMK_DATA))
{
  ;
//  ioctl(_hVTMK4VxD, TMK_IOCbcdefintsig, _awVTMK4InBuf, 4, _awVTMK4OutBuf, 0, &_VTMK4Arg, NULL);
}
*/

int bcreset()
{
  return (
#ifdef USE_TMK_ERROR
    tmkError = 
#endif  
    ioctl(_hVTMK4VxD, TMK_IOCbcreset));
}

/*
void bc_def_tldw(TMK_DATA wTLDW)
{
  ioctl(_hVTMK4VxD, TMK_IOCbc_def_tldw, wTLDW);
}
void bc_enable_di()
{
  ioctl(_hVTMK4VxD, TMK_IOCbc_enable_di);
}
void bc_disable_di()
{
  ioctl(_hVTMK4VxD, TMK_IOCbc_disable_di);
}
*/

int bcdefirqmode(TMK_DATA bcIrqMode)
{
  return (
#ifdef USE_TMK_ERROR
    tmkError =
#endif  
    ioctl(_hVTMK4VxD, TMK_IOCbcdefirqmode, bcIrqMode));
}

TMK_DATA_RET bcgetirqmode()
{
#ifdef USE_TMK_ERROR
  tmkError = 0;
#endif  
  return (ioctl(_hVTMK4VxD, TMK_IOCbcgetirqmode));
}

TMK_DATA_RET bcgetmaxbase()
{
#ifdef USE_TMK_ERROR
  tmkError = 0;
#endif  
  return (ioctl(_hVTMK4VxD, TMK_IOCbcgetmaxbase));
}

int bcdefbase(TMK_DATA bcBasePC)
{
  return (
#ifdef USE_TMK_ERROR
    tmkError =
#endif  
    ioctl(_hVTMK4VxD, TMK_IOCbcdefbase, bcBasePC));
}

TMK_DATA_RET bcgetbase()
{
#ifdef USE_TMK_ERROR
  tmkError = 0;
#endif  
  return (ioctl(_hVTMK4VxD, TMK_IOCbcgetbase));
}

void bcputw(TMK_DATA bcAddr, TMK_DATA bcData)
{
#ifdef USE_TMK_ERROR
  tmkError = 
#endif  
  ioctl(_hVTMK4VxD, TMK_IOCbcputw, bcAddr | (bcData << 16));
}

TMK_DATA_RET bcgetw(TMK_DATA bcAddr)
{
#ifdef USE_TMK_ERROR
  tmkError = 0;
#endif  
  return ioctl(_hVTMK4VxD, TMK_IOCbcgetw, bcAddr);
}

DWORD bcgetansw(TMK_DATA bcCtrlCode)
{
  DWORD _VTMK4Arg;
  _VTMK4Arg = bcCtrlCode;
#ifdef USE_TMK_ERROR
  tmkError = 
#endif  
  ioctl(_hVTMK4VxD, TMK_IOCbcgetansw, &_VTMK4Arg);
  return _VTMK4Arg;
}

void bcputblk(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength)
{
  DWORD _VTMK4Arg[2];
/*
  _awVTMK4InBuf[0] = bcAddr;
  _awVTMK4InBuf[1] = cwLength;
  _awVTMK4InBuf[2] = (WORD)(LOWORD(pcBuffer));
  _awVTMK4InBuf[3] = (WORD)(HIWORD(pcBuffer));
*/
  _VTMK4Arg[0] = bcAddr | (cwLength << 16);
  _VTMK4Arg[1] = (DWORD)pcBuffer;
#ifdef USE_TMK_ERROR
  tmkError = 
#endif  
  ioctl(_hVTMK4VxD, TMK_IOCbcputblk, &_VTMK4Arg);
}

void bcgetblk(TMK_DATA bcAddr, void *pcBuffer, TMK_DATA cwLength)
{
  DWORD _VTMK4Arg[2];
/*
  _awVTMK4InBuf[0] = bcAddr;
  _awVTMK4InBuf[1] = cwLength;
  _awVTMK4InBuf[2] = (WORD)(LOWORD(pcBuffer));
  _awVTMK4InBuf[3] = (WORD)(HIWORD(pcBuffer));
*/
  _VTMK4Arg[0] = bcAddr | (cwLength << 16);
  _VTMK4Arg[1] = (DWORD)pcBuffer;
#ifdef USE_TMK_ERROR
  tmkError = 
#endif  
  ioctl(_hVTMK4VxD, TMK_IOCbcgetblk, _VTMK4Arg);
}

int bcdefbus(TMK_DATA bcBus)
{
  return (
#ifdef USE_TMK_ERROR
    tmkError =
#endif  
    ioctl(_hVTMK4VxD, TMK_IOCbcdefbus, bcBus));
}

TMK_DATA_RET bcgetbus()
{
#ifdef USE_TMK_ERROR
  tmkError = 0;
#endif  
  return (ioctl(_hVTMK4VxD, TMK_IOCbcgetbus));
}

int bcstart(TMK_DATA bcBase, TMK_DATA bcCtrlCode)
{
  return (
#ifdef USE_TMK_ERROR
    tmkError =
#endif  
    ioctl(_hVTMK4VxD, TMK_IOCbcstart, bcBase | (bcCtrlCode << 16)));