/**************************************************************************** ** use1401.c ** Copyright (C) Cambridge Electronic Design Ltd, 1992-2010 ** ** 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ** ** Contact CED: Cambridge Electronic Design Limited, Science Park, Milton Road ** Cambridge, CB6 0FE. ** www.ced.co.uk ** greg@ced.co.uk ** ** Title: USE1401.C ** Version: 4.00 ** Author: Paul Cox, Tim Bergel, Greg Smith ** ** The code was vigorously pruned in DEC 2010 to remove the macintosh options ** and to get rid of the 16-bit support. It has also been aligned with the ** Linux version. See CVS for revisions. This will work for Win 9x onwards. **************************************************************************** ** ** Notes on Windows interface to driver ** ************************************ ** ** Under Windows 9x and NT, Use1401 uses DeviceIoControl to get access to ** the 1401 driver. This has parameters for the device handle, the function ** code, an input pointer and byte count, an output pointer and byte count ** and a pointer to a unsigned int to hold the output byte count. Note that input ** and output are from the point-of-view of the driver, so the output stuff ** is used to read values from the 1401, not send to the 1401. The use of ** these parameters varies with the function in use and the operating ** system; there are five separate DIOC calls SendString, GetString and ** SetTransferArea all have their own specialised calls, the rest use the ** Status1401 or Control1401 functions. ** ** There are two basic styles of DIOC call used, one for Win9x VxD drivers ** and one for NT Kernel-mode and WDM drivers (see below for tables showing ** the different parameters used. The array bUseNTDIOC[] selects between ** these two calling styles. ** ** Function codes ** In Win3.x, simple function codes from 0 to 40 were used, shifted left 8 ** bits with a sub-function code in the lower 8 bits. These were also used ** in the Windows 95 driver, though we had to add 1 to the code value to ** avoid problems (Open from CreateFile is zero), and the sub-function code ** is now unused. We found that this gave some problems with Windows 98 ** as the function code values are reserved by microsoft, so we switched to ** using the NT function codes instead. The NT codes are generated using the ** CTL_CODE macro, essentially this gives 0x80012000 | (func << 2), where ** func is the original 0 to 34 value. The driver will handle both types of ** code and Use1432 only uses the NT codes if it knows the driver is new ** enough. The array bUseNTCodes[] holds flags on the type of codes required. ** GPS/TDB Dec 2010: we removed the bUseNTCodes array as this is always true ** as we no longer support ancient versions. ** ** The CreateFile and CloseFile function calls are also handled ** by DIOC, using the special function codes 0 and -1 respectively. ** ** Input pointer and buffer size ** These are intended for data sent to the device driver. In nearly all cases ** they are unused in calls to the Win95 driver, the NT driver uses them ** for all information sent to the driver. The table below shows the pointer ** and byte count used for the various calls: ** ** Win 95 Win NT ** SendString NULL, 0 pStr, nStr ** GetString NULL, 0 NULL, 0 ** SetTransferArea pBuf, nBuf (unused?) pDesc, nDesc ** GetTransfer NULL, 0 NULL, 0 ** Status1401 NULL, 0 NULL, 0 ** Control1401 NULL, 0 pBlk, nBlk ** ** pStr and nStr are pointers to a char buffer and the buffer length for ** string I/O, note that these are temporary buffers owned by the DLL, not ** application memory, pBuf and nBuf are the transfer area buffer (I think ** these are unused), pDesc and nDesc are the TRANSFERDESC structure, pBlk ** and nBlk are the TCSBLOCK structure. ** ** ** Output pointer and buffer size ** These are intended for data read from the device driver. These are used ** for almost all information sent to the Win95 driver, the NT driver uses ** them for information read from the driver, chiefly the error code. The ** table below shows the pointer and byte count used for the various calls: ** ** Win 95 Win NT ** SendString pStr, nStr pPar, nPar ** GetString pStr, nStr+2 pStr, nStr+2 ** SetTransferArea pDesc, nDesc pPar, nPar ** GetTransfer pGet, nGet pGet, nGet ** Status1401 pBlk, nBlk pPar, nPar ** Control1401 pBlk, nBlk pPar, nPar ** ** pStr and nStr are pointers to a char buffer and the buffer length for ** string I/O, the +2 for GetString refers to two spare bytes at the start ** used to hold the string length and returning an error code for NT. Note ** again that these are (and must be) DLL-owned temporary buffers. pPar ** and nPar are a PARAM structure used in NT (it holds an error code and a ** TCSBLOCK structure). pDesc and nDesc are the VXTRANSFERDESC structure, ** pBlk and nBlk are the TCSBLOCK structure. pGet and nGet indicate the ** TGET_TX_BLOCK structure used for GetTransfer. ** ** ** The output byte count ** Both drivers return the output buffer size here, regardless of the actual ** bytes output. This is used to check that we did get through to the driver. ** ** Multiple 1401s ** ************** ** ** We have code that tries to support the use of multiple 1401s, but there ** are problems: The lDriverVersion and lDriverType variables are global, not ** per-1401 (a particular problem as the U14 functions that use them don't ** have a hand parameter). In addition, the mechansim for finding a free ** 1401 depends upon the 1401 device driver open operation failing if it's ** already in use, which doesn't always happen, particularly with the VxDs. ** The code in TryToOpen tries to fix this by relying on TYPEOF1401 to detect ** the 1401-in-use state - the VxDs contain special code to help this. This is ** working OK but multiple 1401 support works better with the Win2000 drivers. ** ** USB driver ** ********** ** ** The USB driver, which runs on both Win98 and NT2000, uses the NT-style ** calling convention, both for the DIOC codes and the DIOC parameters. The ** TryToOpen function has been altered to look for an NT driver first in ** the appropriate circumstances, and to set the driver DIOC flags up in ** the correct state. ** ** Adding a new 1401 type - now almost nothing to do ** ************************************************* ** ** The 1401 types are defined by a set of U14TYPExxxx codes in USE1401.H. ** You should add a new one of these to keep things tidy for applications. ** ** DRIVERET_MAX (below) specifies the maximum allowed type code from the ** 1401 driver; I have set this high to accommodate as yet undesigned 1401 ** types. Similarly, as long as the command file names follow the ARM, ** ARN, ARO sequence, these are calculated by the ExtForType function, so ** you don't need to do anything here either. ** ** Version number ** ************** ** The new U14InitLib() function returns 0 if the OS is incapable of use, ** otherwise is returns the version of the USE1401 library. This is done ** in three parts: Major(31-24).Minor(23-16).Revision.(15-0) (brackets are ** the bits used). The Major number starts at 2 for the first revision with ** the U14InitLib() function. Changes to the Major version means that we ** have broken backwards compatibility. Minor number changes mean that we ** have added new functionality that does not break backwards compatibility. ** we starts at 0. Revision changes mean we have fixed something. Each index ** returns to 0 when a higher one changes. */ #define U14LIB_MAJOR 4 #define U14LIB_MINOR 0 #define U14LIB_REVISION 0 #define U14LIB_VERSION ((U14LIB_MAJOR<<24) | (U14LIB_MINOR<<16) | U14LIB_REVISION) #include #include #include #include "USE1401.H" #ifdef _IS_WINDOWS_ #include #include #pragma warning(disable: 4100) /* Disable "Unused formal parameter" warning */ #include #include "process.h" #define sprintf wsprintf #define PATHSEP '\\' #define PATHSEPSTR "\\" #define DEFCMDPATH "\\1401\\" // default command path if all else fails #define MINDRIVERMAJREV 1 // minimum driver revision level we need #define __packed // does nothing in Windows #include "use14_ioc.h" // links to device driver stuff #endif #ifdef LINUX #include #include #include #include #include #include #include #define PATHSEP '/' #define PATHSEPSTR "/" #define DEFCMDPATH "/var/1401/" // default command path if all else fails #define MINDRIVERMAJREV 2 // minimum driver revision level we need #include "ced_ioctl.h" // links to device driver stuff #endif #define MAX1401 8 // The number of 1401s that can be supported /* ** These are the 1401 type codes returned by the driver, they are a slightly ** odd sequence & start for reasons of compatibility with the DOS driver. ** The maximum code value is the upper limit of 1401 device types. */ #define DRIVRET_STD 4 // Codes for 1401 types matching driver values #define DRIVRET_U1401 5 // This table does not need extending, as #define DRIVRET_PLUS 6 // we can calculate values now. #define DRIVRET_POWER 7 // but we need all of these values still #define DRIVRET_MAX 26 // Maximum tolerated code - future designs /* ** These variables store data that will be used to generate the last ** error string. For now, a string will hold the 1401 command file name. */ static char szLastName[20]; // additional text information /* ** Information stored per handle. NBNB, driverType and DriverVersion used to be ** only stored once for all handles... i.e. nonsensical. This change means that ** three U14...() calls now include handles that were previously void. We have ** set a constructor and a destructor call for the library (see the end) to ** initialise important structures, or call use1401_load(). */ static short asDriverType[MAX1401] = {0}; static int lLastDriverVersion = U14ERR_NO1401DRIV; static int lLastDriverType = U14TYPEUNKNOWN; static int alDriverVersion[MAX1401]; // version/type of each driver static int alTimeOutPeriod[MAX1401]; // timeout time in milliseconds static short asLastRetCode[MAX1401]; // last code from a fn call static short asType1401[MAX1401] = {0}; // The type of the 1401 static BOOL abGrabbed[MAX1401] = {0}; // Flag for grabbed, set true by grab1401 static int iAttached = 0; // counts process attaches so can let go #ifdef _IS_WINDOWS_ /**************************************************************************** ** Windows NT Specific Variables and internal types ****************************************************************************/ static HANDLE aHand1401[MAX1401] = {0}; // handles for 1401s static HANDLE aXferEvent[MAX1401] = {0}; // transfer events for the 1401s static LPVOID apAreas[MAX1401][MAX_TRANSAREAS]; // Locked areas static unsigned int auAreas[MAX1401][MAX_TRANSAREAS]; // Size of locked areas static BOOL bWindows9x = FALSE; // if we are Windows 95 or better #ifdef _WIN64 #define USE_NT_DIOC(ind) TRUE #else static BOOL abUseNTDIOC[MAX1401]; // Use NT-style DIOC parameters */ #define USE_NT_DIOC(ind) abUseNTDIOC[ind] #endif #endif #ifdef LINUX static int aHand1401[MAX1401] = {0}; // handles for 1401s #define INVALID_HANDLE_VALUE 0 // to avoid code differences #endif /* ** The CmdHead relates to backwards compatibility with ancient Microsoft (and Sperry!) ** versions of BASIC, where this header was needed so we could load a command into ** memory. */ #pragma pack(1) // pack our structure typedef struct CmdHead // defines header block on command { // for PC commands char acBasic[5]; // BASIC information - needed to align things unsigned short wBasicSz; // size as seen by BASIC unsigned short wCmdSize; // size of the following info } __packed CMDHEAD; #pragma pack() // back to normal /* ** The rest of the header looks like this... ** int iRelPnt; relocation pointer... actual start ** char acName[8]; string holding the command name ** BYTE bMonRev; monitor revision level ** BYTE bCmdRev; command revision level */ typedef CMDHEAD *LPCMDHEAD; // pointer to a command header #define MAXSTRLEN 255 // maximum string length we use #define TOHOST FALSE #define TO1401 TRUE static short CheckHandle(short h) { if ((h < 0) || (h >= MAX1401)) // must be legal range... return U14ERR_BADHAND; if (aHand1401[h] <= 0) // must be open return U14ERR_BADHAND; return U14ERR_NOERROR; } #ifdef _IS_WINDOWS_ /**************************************************************************** ** U14Status1401 Used for functions which do not pass any data in but ** get data back ****************************************************************************/ static short U14Status1401(short sHand, LONG lCode, TCSBLOCK* pBlk) { unsigned int dwBytes = 0; if ((sHand < 0) || (sHand >= MAX1401)) /* Check parameters */ return U14ERR_BADHAND; #ifndef _WIN64 if (!USE_NT_DIOC(sHand)) { /* Windows 9x DIOC methods? */ if (DeviceIoControl(aHand1401[sHand], lCode, NULL, 0, pBlk,sizeof(TCSBLOCK),&dwBytes,NULL)) return (short)((dwBytes>=sizeof(TCSBLOCK)) ? U14ERR_NOERROR : U14ERR_DRIVCOMMS); else return (short)GetLastError(); } else #endif { /* Windows NT or USB driver */ PARAMBLK rWork; rWork.sState = U14ERR_DRIVCOMMS; if (DeviceIoControl(aHand1401[sHand], lCode, NULL, 0, &rWork,sizeof(PARAMBLK),&dwBytes,NULL) && (dwBytes >= sizeof(PARAMBLK))) { *pBlk = rWork.csBlock; return rWork.sState; } } return U14ERR_DRIVCOMMS; } /**************************************************************************** ** U14Control1401 Used for functions which pass data in and only expect ** an error code back ****************************************************************************/ static short U14Control1401(short sHand, LONG lCode, TCSBLOCK* pBlk) { unsigned int dwBytes = 0; if ((sHand < 0) || (sHand >= MAX1401)) /* Check parameters */ return U14ERR_BADHAND; #ifndef _WIN64 if (!USE_NT_DIOC(sHand)) { /* Windows 9x DIOC methods */ if (DeviceIoControl(aHand1401[sHand], lCode, NULL, 0, pBlk, sizeof(TCSBLOCK), &dwBytes, NULL)) return (short)(dwBytes >= sizeof(TCSBLOCK) ? U14ERR_NOERROR : U14ERR_DRIVCOMMS); else return (short)GetLastError(); } else #endif { /* Windows NT or later */ PARAMBLK rWork; rWork.sState = U14ERR_DRIVCOMMS; if (DeviceIoControl(aHand1401[sHand], lCode, pBlk, sizeof(TCSBLOCK), &rWork, sizeof(PARAMBLK), &dwBytes, NULL) && (dwBytes >= sizeof(PARAMBLK))) return rWork.sState; } return U14ERR_DRIVCOMMS; } #endif /**************************************************************************** ** SafeTickCount ** Gets time in approximately units of a millisecond. *****************************************************************************/ static long SafeTickCount() { #ifdef _IS_WINDOWS_ return GetTickCount(); #endif #ifdef LINUX struct timeval tv; gettimeofday(&tv, NULL); return (tv.tv_sec*1000 + tv.tv_usec/1000); #endif } /**************************************************************************** ** A utility routine to get the command file extension for a given type ** of 1401. We assume the type code is vaguely legal. ****************************************************************************/ static int ExtForType(short sType, char* szExt) { szExt[0] = 0; /* Default return is a blank string */ switch (sType) { case U14TYPE1401: strcpy(szExt, ".CMD"); break; // Standard 1401 case U14TYPEPLUS: strcpy(szExt, ".GXC"); break; // 1401 plus default: // All others are in a predictable sequence strcpy(szExt, ".ARM"); szExt[3] = (char)('M' + sType - U14TYPEU1401); if (szExt[3] > 'Z') // Wrap round to ARA after ARZ szExt[3] = (char)(szExt[3] - 26); } return 0; } /**************************************************************************** ** U14WhenToTimeOut ** Returns the time to time out in time units suitable for the machine ** we are running on ie millsecs for pc/linux, or Mac/ ****************************************************************************/ U14API(int) U14WhenToTimeOut(short hand) { int iNow = SafeTickCount(); if ((hand >= 0) && (hand < MAX1401)) iNow += alTimeOutPeriod[hand]; return iNow; } /**************************************************************************** ** U14PassedTime ** Returns non zero if the timed passed in has been passed 0 if not ****************************************************************************/ U14API(short) U14PassedTime(int lCheckTime) { return (short)((SafeTickCount()-lCheckTime) > 0); } /**************************************************************************** ** TranslateString ** Tidies up string that U14GetString returns. Converts all the commas in a ** string to spaces. Removes terminating CR character. May do more in future. ****************************************************************************/ static void TranslateString(char* pStr) { int i = 0; while (pStr[i]) { if (pStr[i] == ',') pStr[i] = ' '; /* convert comma to space */ ++i; } if ((i > 0) && (pStr[i-1] == '\n')) /* kill terminating LF */ pStr[i-1] = (char)0; } /**************************************************************************** ** U14StrToLongs ** Converts a string to an array of longs and returns the number of values ****************************************************************************/ U14API(short) U14StrToLongs(const char* pszBuff, U14LONG *palNums, short sMaxLongs) { unsigned short wChInd = 0; // index into source short sLgInd = 0; // index into result longs while (pszBuff[wChInd] && // until we get to end of string... (sLgInd < sMaxLongs)) // ...or filled the buffer { // Why not use a C Library converter? switch (pszBuff[wChInd]) { case '-': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': { BOOL bDone = FALSE; // true at end of number int iSign = 1; // sign of number long lValue = 0; while ((!bDone) && pszBuff[wChInd]) { switch (pszBuff[wChInd]) { case '-': iSign = -1; // swap sign break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': lValue *= 10; // move to next digit base 10 lValue += ((int)pszBuff[wChInd]-(int)'0'); break; default: // end of number bDone = TRUE; break; } wChInd++; // move onto next character } palNums[sLgInd] = lValue * iSign; sLgInd++; } break; default: wChInd++; // look at next char break; } } return (sLgInd); } /**************************************************************************** ** U14LongsFrom1401 ** Gets the next waiting line from the 1401 and converts it longs ** Returns the number of numbers read or an error. ****************************************************************************/ U14API(short) U14LongsFrom1401(short hand, U14LONG *palBuff, short sMaxLongs) { char szWork[MAXSTRLEN]; short sResult = U14GetString(hand, szWork, MAXSTRLEN);/* get reply from 1401 */ if (sResult == U14ERR_NOERROR) /* if no error convert */ sResult = U14StrToLongs(szWork, palBuff, sMaxLongs); return sResult; } /**************************************************************************** ** U14CheckErr ** Sends the ERR command to the 1401 and gets the result. Returns 0, a ** negative error code, or the first error value. ****************************************************************************/ U14API(short) U14CheckErr(short hand) { short sResult = U14SendString(hand, ";ERR;"); if (sResult == U14ERR_NOERROR) { U14LONG er[3]; sResult = U14LongsFrom1401(hand, er, 3); if (sResult > 0) { sResult = (short)er[0]; /* Either zero or an error value */ #ifdef _DEBUG if (er[0] != 0) { char szMsg[50]; sprintf(szMsg, "U14CheckErr returned %d,%d\n", er[0], er[1]); OutputDebugString(szMsg); } #endif } else { if (sResult == 0) sResult = U14ERR_TIMEOUT; /* No numbers equals timeout */ } } return sResult; } /**************************************************************************** ** U14LastErrCode ** Returns the last code from the driver. This is for Windows where all calls ** go through the Control and Status routines, so we can save any error. ****************************************************************************/ U14API(short) U14LastErrCode(short hand) { if ((hand < 0) || (hand >= MAX1401)) return U14ERR_BADHAND; return asLastRetCode[hand]; } /**************************************************************************** ** U14SetTimeout ** Set the timeout period for 1401 comms in milliseconds ****************************************************************************/ U14API(void) U14SetTimeout(short hand, int lTimeOut) { if ((hand < 0) || (hand >= MAX1401)) return; alTimeOutPeriod[hand] = lTimeOut; } /**************************************************************************** ** U14GetTimeout ** Get the timeout period for 1401 comms in milliseconds ****************************************************************************/ U14API(int) U14GetTimeout(short hand) { if ((hand < 0) || (hand >= MAX1401)) return U14ERR_BADHAND; return alTimeOutPeriod[hand]; } /**************************************************************************** ** U14OutBufSpace ** Return the space in the output buffer, or an error. ****************************************************************************/ U14API(short) U14OutBufSpace(short hand) { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; short sErr = U14Status1401(hand, U14_GETOUTBUFSPACE,&csBlock); if (sErr == U14ERR_NOERROR) sErr = csBlock.ints[0]; return sErr; #endif #ifdef LINUX short sErr = CheckHandle(hand); return (sErr == U14ERR_NOERROR) ? CED_GetOutBufSpace(aHand1401[hand]) : sErr; #endif } /**************************************************************************** ** U14BaseAddr1401 ** Returns the 1401 base address or an error code. Meaningless nowadays ****************************************************************************/ U14API(int) U14BaseAddr1401(short hand) { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; int iError = U14Status1401(hand, U14_GETBASEADDRESS,&csBlock); if (iError == U14ERR_NOERROR) iError = csBlock.longs[0]; return iError; #endif #ifdef LINUX short sErr = CheckHandle(hand); return (sErr == U14ERR_NOERROR) ? CED_GetBaseAddress(aHand1401[hand]) : sErr; #endif } /**************************************************************************** ** U14StateOf1401 ** Return error state, either NOERROR or a negative code. ****************************************************************************/ U14API(short) U14StateOf1401(short hand) { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; short sErr = U14Status1401(hand, U14_STATEOF1401, &csBlock); if (sErr == U14ERR_NOERROR) { sErr = csBlock.ints[0]; // returned 1401 state if ((sErr >= DRIVRET_STD) && (sErr <= DRIVRET_MAX)) sErr = U14ERR_NOERROR; } #endif #ifdef LINUX short sErr = CheckHandle(hand); if (sErr == U14ERR_NOERROR) { sErr = (short)CED_StateOf1401(aHand1401[hand]); if ((sErr >= DRIVRET_STD) && (sErr <= DRIVRET_MAX)) sErr = U14ERR_NOERROR; } #endif return sErr; } /**************************************************************************** ** U14DriverVersion ** Returns the driver version. Hi word is major revision, low word is minor. ** If you pass in a silly handle (like -1), we return the version of the last ** driver we know of (to cope with PCI and no 1401 attached). ****************************************************************************/ U14API(int) U14DriverVersion(short hand) { return CheckHandle(hand) != U14ERR_NOERROR ? lLastDriverVersion : alDriverVersion[hand]; } /**************************************************************************** ** U14DriverType ** Returns the driver type. The type, 0=ISA/NU-Bus, 1=PCI, 2=USB, 3=HSS ** If you pass in a silly handle (like -1), we return the type of the last ** driver we know of (to cope with PCI and no 1401 attached). ****************************************************************************/ U14API(int) U14DriverType(short hand) { return CheckHandle(hand) != U14ERR_NOERROR ? lLastDriverType : asDriverType[hand]; } /**************************************************************************** ** U14DriverName ** Returns the driver type as 3 character (ISA, PCI, USB or HSS)) ****************************************************************************/ U14API(short) U14DriverName(short hand, char* pBuf, unsigned short wMax) { char* pName; *pBuf = 0; // Start off with a blank string switch (U14DriverType(hand)) // Results according to type { case 0: pName = "ISA"; break; case 1: pName = "PCI"; break; case 2: pName = "USB"; break; case 3: pName = "HSS"; break; default: pName = "???"; break; } strncpy(pBuf, pName, wMax); // Copy the correct name to return return U14ERR_NOERROR; } /**************************************************************************** ** U14BlkTransState ** Returns 0 no transfer in progress, 1 transfer in progress or an error code ****************************************************************************/ U14API(short) U14BlkTransState(short hand) { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; short sErr = U14Status1401(hand, U14_BLKTRANSSTATE, &csBlock); if (sErr == U14ERR_NOERROR) sErr = csBlock.ints[0]; return sErr; #endif #ifdef LINUX short sErr = CheckHandle(hand); return (sErr == U14ERR_NOERROR) ? CED_BlkTransState(aHand1401[hand]) : sErr; #endif } /**************************************************************************** ** U14Grab1401 ** Take control of the 1401 for diagnostics purposes. USB does nothing. ****************************************************************************/ U14API(short) U14Grab1401(short hand) { short sErr = CheckHandle(hand); if (sErr == U14ERR_NOERROR) { #ifdef _IS_WINDOWS_ if (abGrabbed[hand]) // 1401 should not have been grabbed sErr = U14ERR_ALREADYSET; // Error code defined for this else { TCSBLOCK csBlock; sErr = U14Control1401(hand, U14_GRAB1401, &csBlock); } #endif #ifdef LINUX // 1401 should not have been grabbed sErr = abGrabbed[hand] ? U14ERR_ALREADYSET : CED_Grab1401(aHand1401[hand]); #endif if (sErr == U14ERR_NOERROR) abGrabbed[hand] = TRUE; } return sErr; } /**************************************************************************** ** U14Free1401 ****************************************************************************/ U14API(short) U14Free1401(short hand) { short sErr = CheckHandle(hand); if (sErr == U14ERR_NOERROR) { #ifdef _IS_WINDOWS_ if (abGrabbed[hand]) // 1401 should have been grabbed { TCSBLOCK csBlock; sErr = U14Control1401(hand, U14_FREE1401, &csBlock); } else sErr = U14ERR_NOTSET; #endif #ifdef LINUX // 1401 should not have been grabbed sErr = abGrabbed[hand] ? CED_Free1401(aHand1401[hand]) : U14ERR_NOTSET; #endif if (sErr == U14ERR_NOERROR) abGrabbed[hand] = FALSE; } return sErr; } /**************************************************************************** ** U14Peek1401 ** DESCRIPTION Cause the 1401 to do one or more peek operations. ** If lRepeats is zero, the loop will continue until U14StopDebugLoop ** is called. After the peek is done, use U14GetDebugData to retrieve ** the results of the peek. ****************************************************************************/ U14API(short) U14Peek1401(short hand, unsigned int dwAddr, int nSize, int nRepeats) { short sErr = CheckHandle(hand); if (sErr == U14ERR_NOERROR) { if (abGrabbed[hand]) // 1401 should have been grabbed { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; csBlock.longs[0] = (long)dwAddr; csBlock.longs[1] = nSize; csBlock.longs[2] = nRepeats; sErr = U14Control1401(hand, U14_DBGPEEK, &csBlock); #endif #ifdef LINUX TDBGBLOCK dbb; dbb.iAddr = (int)dwAddr; dbb.iWidth = nSize; dbb.iRepeats = nRepeats; sErr = CED_DbgPeek(aHand1401[hand], &dbb); #endif } else sErr = U14ERR_NOTSET; } return sErr; } /**************************************************************************** ** U14Poke1401 ** DESCRIPTION Cause the 1401 to do one or more poke operations. ** If lRepeats is zero, the loop will continue until U14StopDebugLoop ** is called. ****************************************************************************/ U14API(short) U14Poke1401(short hand, unsigned int dwAddr, unsigned int dwValue, int nSize, int nRepeats) { short sErr = CheckHandle(hand); if (sErr == U14ERR_NOERROR) { if (abGrabbed[hand]) // 1401 should have been grabbed { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; csBlock.longs[0] = (long)dwAddr; csBlock.longs[1] = nSize; csBlock.longs[2] = nRepeats; csBlock.longs[3] = (long)dwValue; sErr = U14Control1401(hand, U14_DBGPOKE, &csBlock); #endif #ifdef LINUX TDBGBLOCK dbb; dbb.iAddr = (int)dwAddr; dbb.iWidth = nSize; dbb.iRepeats= nRepeats; dbb.iData = (int)dwValue; sErr = CED_DbgPoke(aHand1401[hand], &dbb); #endif } else sErr = U14ERR_NOTSET; } return sErr; } /**************************************************************************** ** U14Ramp1401 ** DESCRIPTION Cause the 1401 to loop, writing a ramp to a location. ** If lRepeats is zero, the loop will continue until U14StopDebugLoop. ****************************************************************************/ U14API(short) U14Ramp1401(short hand, unsigned int dwAddr, unsigned int dwDef, unsigned int dwEnable, int nSize, int nRepeats) { short sErr = CheckHandle(hand); if (sErr == U14ERR_NOERROR) { if (abGrabbed[hand]) // 1401 should have been grabbed { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; csBlock.longs[0] = (long)dwAddr; csBlock.longs[1] = (long)dwDef; csBlock.longs[2] = (long)dwEnable; csBlock.longs[3] = nSize; csBlock.longs[4] = nRepeats; sErr = U14Control1401(hand, U14_DBGRAMPDATA, &csBlock); #endif #ifdef LINUX TDBGBLOCK dbb; dbb.iAddr = (int)dwAddr; dbb.iDefault = (int)dwDef; dbb.iMask = (int)dwEnable; dbb.iWidth = nSize; dbb.iRepeats = nRepeats; sErr = CED_DbgRampAddr(aHand1401[hand], &dbb); #endif } else sErr = U14ERR_NOTSET; } return sErr; } /**************************************************************************** ** U14RampAddr ** DESCRIPTION Cause the 1401 to loop, reading from a ramping location. ** If lRepeats is zero, the loop will continue until U14StopDebugLoop ****************************************************************************/ U14API(short) U14RampAddr(short hand, unsigned int dwDef, unsigned int dwEnable, int nSize, int nRepeats) { short sErr = CheckHandle(hand); if (sErr == U14ERR_NOERROR) { if (abGrabbed[hand]) // 1401 should have been grabbed { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; csBlock.longs[0] = (long)dwDef; csBlock.longs[1] = (long)dwEnable; csBlock.longs[2] = nSize; csBlock.longs[3] = nRepeats; sErr = U14Control1401(hand, U14_DBGRAMPADDR, &csBlock); #endif #ifdef LINUX TDBGBLOCK dbb; dbb.iDefault = (int)dwDef; dbb.iMask = (int)dwEnable; dbb.iWidth = nSize; dbb.iRepeats = nRepeats; sErr = CED_DbgRampAddr(aHand1401[hand], &dbb); #endif } else sErr = U14ERR_NOTSET; } return sErr; } /**************************************************************************** ** U14StopDebugLoop ** DESCRIPTION Stops a peek\poke\ramp that, with repeats set to zero, ** will otherwise continue forever. ****************************************************************************/ U14API(short) U14StopDebugLoop(short hand) { short sErr = CheckHandle(hand); if (sErr == U14ERR_NOERROR) #ifdef _IS_WINDOWS_ { if (abGrabbed[hand]) // 1401 should have been grabbed { TCSBLOCK csBlock; sErr = U14Control1401(hand, U14_DBGSTOPLOOP, &csBlock); } else sErr = U14ERR_NOTSET; } #endif #ifdef LINUX sErr = abGrabbed[hand] ? CED_DbgStopLoop(aHand1401[hand]) : U14ERR_NOTSET; #endif return sErr; } /**************************************************************************** ** U14GetDebugData ** DESCRIPTION Returns the result from a previous peek operation. ****************************************************************************/ U14API(short) U14GetDebugData(short hand, U14LONG* plValue) { short sErr = CheckHandle(hand); if (sErr == U14ERR_NOERROR) { if (abGrabbed[hand]) // 1401 should have been grabbed { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; sErr = U14Status1401(hand, U14_DBGGETDATA, &csBlock); if (sErr == U14ERR_NOERROR) *plValue = csBlock.longs[0]; // Return the data #endif #ifdef LINUX TDBGBLOCK dbb; sErr = CED_DbgGetData(aHand1401[hand], &dbb); if (sErr == U14ERR_NOERROR) *plValue = dbb.iData; /* Return the data */ #endif } else sErr = U14ERR_NOTSET; } return sErr; } /**************************************************************************** ** U14StartSelfTest ****************************************************************************/ U14API(short) U14StartSelfTest(short hand) { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; return U14Control1401(hand, U14_STARTSELFTEST, &csBlock); #endif #ifdef LINUX short sErr = CheckHandle(hand); return (sErr == U14ERR_NOERROR) ? CED_StartSelfTest(aHand1401[hand]) : sErr; #endif } /**************************************************************************** ** U14CheckSelfTest ****************************************************************************/ U14API(short) U14CheckSelfTest(short hand, U14LONG *pData) { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; short sErr = U14Status1401(hand, U14_CHECKSELFTEST, &csBlock); if (sErr == U14ERR_NOERROR) { pData[0] = csBlock.longs[0]; /* Return the results to user */ pData[1] = csBlock.longs[1]; pData[2] = csBlock.longs[2]; } #endif #ifdef LINUX short sErr = CheckHandle(hand); if (sErr == U14ERR_NOERROR) /* Check parameters */ { TGET_SELFTEST gst; sErr = CED_CheckSelfTest(aHand1401[hand], &gst); if (sErr == U14ERR_NOERROR) { pData[0] = gst.code; /* Return the results to user */ pData[1] = gst.x; pData[2] = gst.y; } } #endif return sErr; } /**************************************************************************** ** U14GetUserMemorySize ****************************************************************************/ U14API(short) U14GetUserMemorySize(short hand, unsigned int *pMemorySize) { // The original 1401 used a different command for getting the size short sErr = U14SendString(hand, (asType1401[hand] == U14TYPE1401) ? "MEMTOP;" : "MEMTOP,?;"); *pMemorySize = 0; /* if we get error then leave size set at 0 */ if (sErr == U14ERR_NOERROR) { U14LONG alLimits[4]; sErr = U14LongsFrom1401(hand, alLimits, 4); if (sErr > 0) /* +ve sErr is the number of values read */ { sErr = U14ERR_NOERROR; /* All OK, flag success */ if (asType1401[hand] == U14TYPE1401) /* result for standard */ *pMemorySize = alLimits[0] - alLimits[1]; /* memtop-membot */ else *pMemorySize = alLimits[0]; /* result for plus or u1401 */ } } return sErr; } /**************************************************************************** ** U14TypeOf1401 ** Returns the type of the 1401, maybe unknown ****************************************************************************/ U14API(short) U14TypeOf1401(short hand) { if ((hand < 0) || (hand >= MAX1401)) /* Check parameters */ return U14ERR_BADHAND; else return asType1401[hand]; } /**************************************************************************** ** U14NameOf1401 ** Returns the type of the 1401 as a string, blank if unknown ****************************************************************************/ U14API(short) U14NameOf1401(short hand, char* pBuf, unsigned short wMax) { short sErr = CheckHandle(hand); if (sErr == U14ERR_NOERROR) { char* pName; switch (asType1401[hand]) // Results according to type { case U14TYPE1401: pName = "Std 1401"; break; case U14TYPEPLUS: pName = "1401plus"; break; case U14TYPEU1401: pName = "micro1401"; break; case U14TYPEPOWER: pName = "Power1401"; break; case U14TYPEU14012:pName = "Micro1401 mk II"; break; case U14TYPEPOWER2:pName = "Power1401 mk II"; break; case U14TYPEU14013:pName = "Micro1401-3"; break; case U14TYPEPOWER3:pName = "Power1401-3"; break; default: pName = "Unknown"; } strncpy(pBuf, pName, wMax); } return sErr; } /**************************************************************************** ** U14TransferFlags ** Returns the driver block transfer flags. ** Bits can be set - see U14TF_ constants in use1401.h *****************************************************************************/ U14API(short) U14TransferFlags(short hand) { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; short sErr = U14Status1401(hand, U14_TRANSFERFLAGS, &csBlock); return (sErr == U14ERR_NOERROR) ? (short)csBlock.ints[0] : sErr; #endif #ifdef LINUX short sErr = CheckHandle(hand); return (sErr == U14ERR_NOERROR) ? CED_TransferFlags(aHand1401[hand]) : sErr; #endif } /**************************************************************************** ** GetDriverVersion ** Actually reads driver version from the device driver. ** Hi word is major revision, low word is minor revision. ** Assumes that hand has been checked. Also codes driver type in bits 24 up. *****************************************************************************/ static int GetDriverVersion(short hand) { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; int iErr = U14Status1401(hand, U14_GETDRIVERREVISION, &csBlock); if (iErr == U14ERR_NOERROR) iErr = csBlock.longs[0]; return iErr; #endif #ifdef LINUX return CED_GetDriverRevision(aHand1401[hand]); #endif } /**************************************************************************** ** U14MonitorRev ** Returns the 1401 monitor revision number. ** The number returned is the minor revision - the part after the ** decimal point - plus the major revision times 1000. *****************************************************************************/ U14API(int) U14MonitorRev(short hand) { int iRev = 0; int iErr = CheckHandle(hand); if (iErr != U14ERR_NOERROR) // Check open and in use return iErr; if (asType1401[hand] >= U14TYPEPOWER2) // The Power2 onwards can give us the monitor { // revision directly for all versions iErr = U14SendString(hand, "INFO,S,28;"); if (iErr == U14ERR_NOERROR) { U14LONG lVals[2]; // Read a single number being the revision iErr = U14LongsFrom1401(hand, lVals, 1); if (iErr > 0) { iErr = U14ERR_NOERROR; iRev = lVals[0]; // This is the minor part of the revision iRev += asType1401[hand] * 10000; } } } else { /* Do it the hard way for older hardware */ iErr = U14SendString(hand, ";CLIST;"); /* ask for command levels */ if (iErr == U14ERR_NOERROR) { while (iErr == U14ERR_NOERROR) { char wstr[50]; iErr = U14GetString(hand, wstr, 45); if (iErr == U14ERR_NOERROR) { char *pstr = strstr(wstr,"RESET"); /* Is this the RESET command? */ if ((pstr == wstr) && (wstr[5] == ' ')) { char *pstr2; size_t l; pstr += 6; /* Move past RESET and followinmg char */ l = strlen(pstr); /* The length of text remaining */ while (((pstr[l-1] == ' ') || (pstr[l-1] == 13)) && (l > 0)) { pstr[l-1] = 0; /* Tidy up string at the end */ l--; /* by removing spaces and CRs */ } pstr2 = strchr(pstr, '.'); /* Find the decimal point */ if (pstr2 != NULL) /* If we found the DP */ { *pstr2 = 0; /* End pstr string at DP */ pstr2++; /* Now past the decimal point */ iRev = atoi(pstr2); /* Get the number after point */ } iRev += (atoi(pstr) * 1000); /* Add first bit * 1000 */ } if ((strlen(wstr) < 3) && (wstr[0] == ' ')) break; /* Spot the last line of results */ } } } } if (iErr == U14ERR_NOERROR) /* Return revision if no error */ iErr = iRev; return iErr; } /**************************************************************************** ** U14TryToOpen Tries to open the 1401 number passed ** Note : This will succeed with NT driver even if no I/F card or ** 1401 switched off, so we check state and close the driver ** if the state is unsatisfactory in U14Open1401. ****************************************************************************/ #ifdef _IS_WINDOWS_ #define U14NAMEOLD "\\\\.\\CED_140%d" #define U14NAMENEW "\\\\.\\CED%d" static short U14TryToOpen(int n1401, long* plRetVal, short* psHandle) { short sErr = U14ERR_NOERROR; HANDLE hDevice = INVALID_HANDLE_VALUE; unsigned int dwErr = 0; int nFirst, nLast, nDev = 0; /* Used for the search for a 1401 */ BOOL bOldName = FALSE; /* start by looking for a modern driver */ if (n1401 == 0) /* If we need to look for a 1401 */ { nFirst = 1; /* Set the search range */ nLast = MAX1401; /* through all the possible 1401s */ } else nFirst = nLast = n1401; /* Otherwise just one 1401 */ while (hDevice == INVALID_HANDLE_VALUE) /* Loop to try for a 1401 */ { for (nDev = nFirst; nDev <= nLast; nDev++) { char szDevName[40]; /* name of the device to open */ sprintf(szDevName, bOldName ? U14NAMEOLD : U14NAMENEW, nDev); hDevice = CreateFile(szDevName, GENERIC_WRITE | GENERIC_READ, 0, 0, /* Unshared mode does nothing as this is a device */ OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (hDevice != INVALID_HANDLE_VALUE)/* Check 1401 if opened */ { TCSBLOCK csBlock; assert(aHand1401[nDev-1] == INVALID_HANDLE_VALUE); // assert if already open aHand1401[nDev-1] = hDevice; /* Save handle for now */ #ifndef _WIN64 // Use DIOC method if not windows 9x or if using new device name abUseNTDIOC[nDev-1] = (BOOL)(!bWindows9x || !bOldName); #endif sErr = U14Status1401((short)(nDev-1), U14_TYPEOF1401, &csBlock); if (sErr == U14ERR_NOERROR) { *plRetVal = csBlock.ints[0]; if (csBlock.ints[0] == U14ERR_INUSE)/* Prevent multi opens */ { CloseHandle(hDevice); /* treat as open failure */ hDevice = INVALID_HANDLE_VALUE; aHand1401[nDev-1] = INVALID_HANDLE_VALUE; sErr = U14ERR_INUSE; } else break; /* Exit from for loop on success */ } else { CloseHandle(hDevice); /* Give up if func fails */ hDevice = INVALID_HANDLE_VALUE; aHand1401[nDev-1] = INVALID_HANDLE_VALUE; } } else { unsigned int dwe = GetLastError(); /* Get error code otherwise */ if ((dwe != ERROR_FILE_NOT_FOUND) || (dwErr == 0)) dwErr = dwe; /* Ignore repeats of 'not found' */ } } if ((hDevice == INVALID_HANDLE_VALUE) &&/* No device found, and... */ (bWindows9x) && /* ...old names are allowed, and... */ (bOldName == FALSE)) /* ...not tried old names yet */ bOldName = TRUE; /* Set flag and go round again */ else break; /* otherwise that's all folks */ } if (hDevice != INVALID_HANDLE_VALUE) /* If we got our device open */ *psHandle = (short)(nDev-1); /* return 1401 number opened */ else { if (dwErr == ERROR_FILE_NOT_FOUND) /* Sort out the error codes */ sErr = U14ERR_NO1401DRIV; /* if file not found */ else if (dwErr == ERROR_NOT_SUPPORTED) sErr = U14ERR_DRIVTOOOLD; /* if DIOC not supported */ else if (dwErr == ERROR_ACCESS_DENIED) sErr = U14ERR_INUSE; else sErr = U14ERR_DRIVCOMMS; /* otherwise assume comms problem */ } return sErr; } #endif #ifdef LINUX static short U14TryToOpen(int n1401, long* plRetVal, short* psHandle) { short sErr = U14ERR_NOERROR; int fh = 0; // will be 1401 handle int iErr = 0; int nFirst, nLast, nDev = 0; // Used for the search for a 1401 if (n1401 == 0) // If we need to look for a 1401 { nFirst = 1; /* Set the search range */ nLast = MAX1401; /* through all the possible 1401s */ } else nFirst = nLast = n1401; /* Otherwise just one 1401 */ for (nDev = nFirst; nDev <= nLast; nDev++) { char szDevName[40]; // name of the device to open sprintf(szDevName,"/dev/cedusb/%d", nDev-1); fh = open(szDevName, O_RDWR); // can only be opened once at a time if (fh > 0) // Check 1401 if opened { int iType1401 = CED_TypeOf1401(fh); // get 1401 type aHand1401[nDev-1] = fh; // Save handle for now if (iType1401 >= 0) { *plRetVal = iType1401; break; // Exit from for loop on success } else { close(fh); // Give up if func fails fh = 0; aHand1401[nDev-1] = 0; } } else { if (((errno != ENODEV) && (errno != ENOENT)) || (iErr == 0)) iErr = errno; // Ignore repeats of 'not found' } } if (fh) // If we got our device open *psHandle = (short)(nDev-1); // return 1401 number opened else { if ((iErr == ENODEV) || (iErr == ENOENT)) // Sort out the error codes sErr = U14ERR_NO1401DRIV; // if file not found else if (iErr == EBUSY) sErr = U14ERR_INUSE; else sErr = U14ERR_DRIVCOMMS; // otherwise assume comms problem } return sErr; } #endif /**************************************************************************** ** U14Open1401 ** Tries to get the 1401 for use by this application *****************************************************************************/ U14API(short) U14Open1401(short n1401) { long lRetVal = -1; short sErr; short hand = 0; if ((n1401 < 0) || (n1401 > MAX1401)) // must check the 1401 number return U14ERR_BAD1401NUM; szLastName[0] = 0; /* initialise the error info string */ sErr = U14TryToOpen(n1401, &lRetVal, &hand); if (sErr == U14ERR_NOERROR) { long lDriverVersion = GetDriverVersion(hand); /* get driver revision */ long lDriverRev = -1; if (lDriverVersion >= 0) /* can use it if all OK */ { lLastDriverType = (lDriverVersion >> 24) & 0x000000FF; asDriverType[hand] = (short)lLastDriverType; /* Drv type */ lLastDriverVersion = lDriverVersion & 0x00FFFFFF; alDriverVersion[hand] = lLastDriverVersion; /* Actual version */ lDriverRev = ((lDriverVersion>>16) & 0x00FF); /* use hi word */ } else { U14Close1401(hand); /* If there is a problem we should close */ return (short)lDriverVersion; /* and return the error code */ } if (lDriverRev < MINDRIVERMAJREV) /* late enough version? */ { U14Close1401(hand); /* If there is a problem we should close */ return U14ERR_DRIVTOOOLD; /* too old */ } asLastRetCode[hand] = U14ERR_NOERROR; /* Initialise this 1401s info */ abGrabbed[hand] = FALSE; /* we are not in single step mode */ U14SetTimeout(hand, 3000); /* set 3 seconds as default timeout */ switch (lRetVal) { case DRIVRET_STD: asType1401[hand] = U14TYPE1401; break; /* Some we do by hand */ case DRIVRET_U1401:asType1401[hand] = U14TYPEU1401; break; case DRIVRET_PLUS: asType1401[hand] = U14TYPEPLUS; break; default: // For the power upwards, we can calculate the codes if ((lRetVal >= DRIVRET_POWER) && (lRetVal <= DRIVRET_MAX)) asType1401[hand] = (short)(lRetVal - (DRIVRET_POWER - U14TYPEPOWER)); else asType1401[hand] = U14TYPEUNKNOWN; break; } U14KillIO1401(hand); /* resets the 1401 buffers */ if (asType1401[hand] != U14TYPEUNKNOWN) /* If all seems OK so far */ { sErr = U14CheckErr(hand); /* we can check 1401 comms now */ if (sErr != 0) /* If this failed to go OK */ U14Reset1401(hand); /* Reset the 1401 to try to sort it out */ } sErr = U14StateOf1401(hand);/* Get the state of the 1401 for return */ if (sErr == U14ERR_NOERROR) sErr = hand; /* return the handle if no problem */ else U14Close1401(hand); /* If there is a problem we should close */ } return sErr; } /**************************************************************************** ** U14Close1401 ** Closes the 1401 so someone else can use it. ****************************************************************************/ U14API(short) U14Close1401(short hand) { int j; int iAreaMask = 0; // Mask for active areas short sErr = CheckHandle(hand); if (sErr != U14ERR_NOERROR) // Check open and in use return sErr; for (j = 0; j MAXSTRLEN) return U14ERR_STRLEN; // String too long #ifdef _IS_WINDOWS_ // To get here we must wait for the buffer to have some space lTimeOutTicks = U14WhenToTimeOut(hand); do { bSpaceToSend = (BOOL)((long)U14OutBufSpace(hand) >= nChars); } while (!bSpaceToSend && !U14PassedTime(lTimeOutTicks)); if (!bSpaceToSend) /* Last-ditch attempt to avoid timeout */ { /* This can happen with anti-virus or network activity! */ int i; for (i = 0; (i < 4) && (!bSpaceToSend); ++i) { Sleep(25); /* Give other threads a chance for a while */ bSpaceToSend = (BOOL)((long)U14OutBufSpace(hand) >= nChars); } } if (asLastRetCode[hand] == U14ERR_NOERROR) /* no errors? */ { if (bSpaceToSend) { PARAMBLK rData; unsigned int dwBytes; char tstr[MAXSTRLEN+5]; /* Buffer for chars */ if ((hand < 0) || (hand >= MAX1401)) sErr = U14ERR_BADHAND; else { strcpy(tstr, pString); /* Into local buf */ #ifndef _WIN64 if (!USE_NT_DIOC(hand)) /* Using WIN 95 driver access? */ { int iOK = DeviceIoControl(aHand1401[hand], (unsigned int)U14_SENDSTRING, NULL, 0, tstr, nChars, &dwBytes, NULL); if (iOK) sErr = (dwBytes >= (unsigned int)nChars) ? U14ERR_NOERROR : U14ERR_DRIVCOMMS; else sErr = (short)GetLastError(); } else #endif { int iOK = DeviceIoControl(aHand1401[hand],(unsigned int)U14_SENDSTRING, tstr, nChars, &rData,sizeof(PARAMBLK),&dwBytes,NULL); if (iOK && (dwBytes >= sizeof(PARAMBLK))) sErr = rData.sState; else sErr = U14ERR_DRIVCOMMS; } if (sErr != U14ERR_NOERROR) // If we have had a comms error U14ForceReset(hand); // make sure we get real reset } return sErr; } else { U14ForceReset(hand); // make sure we get real reset return U14ERR_TIMEOUT; } } else return asLastRetCode[hand]; #endif #ifdef LINUX // Just try to send it and see what happens! sErr = CED_SendString(aHand1401[hand], pString, nChars); if (sErr != U14ERR_NOOUT) // if any result except "no room in output"... { if (sErr != U14ERR_NOERROR) // if a problem... U14ForceReset(hand); // ...make sure we get real reset next time return sErr; // ... we are done as nothing we can do } // To get here we must wait for the buffer to have some space lTimeOutTicks = U14WhenToTimeOut(hand); do { bSpaceToSend = (BOOL)((long)U14OutBufSpace(hand) >= nChars); if (!bSpaceToSend) sched_yield(); // let others have fun while we wait } while (!bSpaceToSend && !U14PassedTime(lTimeOutTicks)); if (asLastRetCode[hand] == U14ERR_NOERROR) /* no errors? */ { if (bSpaceToSend) { sErr = CED_SendString(aHand1401[hand], pString, nChars); if (sErr != U14ERR_NOERROR) // If we have had a comms error U14ForceReset(hand); // make sure we get real reset return sErr; } else { U14ForceReset(hand); // make sure we get real reset return U14ERR_TIMEOUT; } } else return asLastRetCode[hand]; #endif } /**************************************************************************** ** U14SendChar ** Send character to the 1401 *****************************************************************************/ U14API(short) U14SendChar(short hand, char cChar) { #ifdef _IS_WINDOWS_ char sz[2]=" "; // convert to a string and send sz[0] = cChar; sz[1] = 0; return(U14SendString(hand, sz)); // String routines are better #endif #ifdef LINUX short sErr = CheckHandle(hand); return (sErr == U14ERR_NOERROR) ? CED_SendChar(aHand1401[hand], cChar) : sErr; #endif } /**************************************************************************** ** U14GetString ** Get a string from the 1401. Returns a null terminated string. ** The string is all the characters up to the next CR in the buffer ** or the end of the buffer if that comes first. This only returns text ** if there is a CR in the buffer. The terminating CR character is removed. ** wMaxLen Is the size of the buffer and must be at least 2 or an error. ** Returns U14ERR_NOERR if OK with the result in the string or a negative ** error code. Any error from the device causes us to set up for ** a full reset. ****************************************************************************/ U14API(short) U14GetString(short hand, char* pBuffer, unsigned short wMaxLen) { short sErr = CheckHandle(hand); if (sErr != U14ERR_NOERROR) // If an error... return sErr; // ...bail out! #ifdef _IS_WINDOWS_ if (wMaxLen>1) // we need space for terminating 0 { BOOL bLineToGet; // true when a line to get long lTimeOutTicks = U14WhenToTimeOut(hand); do bLineToGet = (BOOL)(U14LineCount(hand) != 0); while (!bLineToGet && !U14PassedTime(lTimeOutTicks)); if (!bLineToGet) /* Last-ditch attempt to avoid timeout */ { /* This can happen with anti-virus or network activity! */ int i; for (i = 0; (i < 4) && (!bLineToGet); ++i) { Sleep(25); /* Give other threads a chance for a while */ bLineToGet = (BOOL)(U14LineCount(hand) != 0); } } if (bLineToGet) { if (asLastRetCode[hand] == U14ERR_NOERROR) /* all ok so far */ { unsigned int dwBytes = 0; *((unsigned short *)pBuffer) = wMaxLen; /* set up length */ #ifndef _WIN64 if (!USE_NT_DIOC(hand)) /* Win 95 DIOC here ? */ { char tstr[MAXSTRLEN+5]; /* Buffer for Win95 chars */ int iOK; if (wMaxLen > MAXSTRLEN) /* Truncate length */ wMaxLen = MAXSTRLEN; *((unsigned short *)tstr) = wMaxLen; /* set len */ iOK = DeviceIoControl(aHand1401[hand],(unsigned int)U14_GETSTRING, NULL, 0, tstr, wMaxLen+sizeof(short), &dwBytes, NULL); if (iOK) /* Device IO control OK ? */ { if (dwBytes >= 0) /* If driver OK */ { strcpy(pBuffer, tstr); sErr = U14ERR_NOERROR; } else sErr = U14ERR_DRIVCOMMS; } else { sErr = (short)GetLastError(); if (sErr > 0) /* Errors are -ve */ sErr = (short)-sErr; } } else #endif { /* Here for NT, the DLL must own the buffer */ HANDLE hMem = GlobalAlloc(GMEM_MOVEABLE,wMaxLen+sizeof(short)); if (hMem) { char* pMem = (char*)GlobalLock(hMem); if (pMem) { int iOK = DeviceIoControl(aHand1401[hand],(unsigned int)U14_GETSTRING, NULL, 0, pMem, wMaxLen+sizeof(short), &dwBytes, NULL); if (iOK) /* Device IO control OK ? */ { if (dwBytes >= wMaxLen) { strcpy(pBuffer, pMem+sizeof(short)); sErr = *((SHORT*)pMem); } else sErr = U14ERR_DRIVCOMMS; } else sErr = U14ERR_DRIVCOMMS; GlobalUnlock(hMem); } else sErr = U14ERR_OUTOFMEMORY; GlobalFree(hMem); } else sErr = U14ERR_OUTOFMEMORY; } if (sErr == U14ERR_NOERROR) // If all OK... TranslateString(pBuffer); // ...convert any commas to spaces else // If we have had a comms error... U14ForceReset(hand); // ...make sure we get real reset } else sErr = asLastRetCode[hand]; } else { sErr = U14ERR_TIMEOUT; U14ForceReset(hand); // make sure we get real reset } } else sErr = U14ERR_BUFF_SMALL; return sErr; #endif #ifdef LINUX if (wMaxLen>1) // we need space for terminating 0 { BOOL bLineToGet; // true when a line to get long lTimeOutTicks = U14WhenToTimeOut(hand); do { bLineToGet = (BOOL)(U14LineCount(hand) != 0); if (!bLineToGet) sched_yield(); } while (!bLineToGet && !U14PassedTime(lTimeOutTicks)); if (bLineToGet) { sErr = CED_GetString(aHand1401[hand], pBuffer, wMaxLen-1); // space for terminator if (sErr >=0) // if we were OK... { if (sErr >= wMaxLen) // this should NOT happen unless sErr = U14ERR_DRIVCOMMS; // ...driver Comms are very bad else { pBuffer[sErr] = 0; // OK, so terminate the string... TranslateString(pBuffer); // ...and convert commas to spaces. } } if (sErr < U14ERR_NOERROR) // If we have had a comms error U14ForceReset(hand); // make sure we get real reset } else { sErr = U14ERR_TIMEOUT; U14ForceReset(hand); // make sure we get real reset } } else sErr = U14ERR_BUFF_SMALL; return sErr >= U14ERR_NOERROR ? U14ERR_NOERROR : sErr; #endif } /**************************************************************************** ** U14GetChar ** Get a character from the 1401. CR returned as CR. *****************************************************************************/ U14API(short) U14GetChar(short hand, char* pcChar) { #ifdef _IS_WINDOWS_ char sz[2]; // read a very short string short sErr = U14GetString(hand, sz, 2); // read one char and nul terminate it *pcChar = sz[0]; // copy to result, NB char translate done by GetString if (sErr == U14ERR_NOERROR) { // undo translate of CR to zero if (*pcChar == '\0') // by converting back *pcChar = '\n'; // What a nasty thing to have to do } return sErr; #endif #ifdef LINUX short sErr = CheckHandle(hand); if (sErr != U14ERR_NOERROR) // Check parameters return sErr; sErr = CED_GetChar(aHand1401[hand]); // get one char, if available if (sErr >= 0) { *pcChar = (char)sErr; // return if it we have one return U14ERR_NOERROR; // say all OK } else return sErr; #endif } /**************************************************************************** ** U14Stat1401 ** Returns 0 for no lines or error or non zero for something waiting ****************************************************************************/ U14API(short) U14Stat1401(short hand) { return ((short)(U14LineCount(hand) > 0)); } /**************************************************************************** ** U14CharCount ** Returns the number of characters in the input buffer *****************************************************************************/ U14API(short) U14CharCount(short hand) { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; short sErr = U14Status1401(hand, U14_STAT1401, &csBlock); if (sErr == U14ERR_NOERROR) sErr = csBlock.ints[0]; return sErr; #endif #ifdef LINUX short sErr = CheckHandle(hand); return (sErr == U14ERR_NOERROR) ? CED_Stat1401(aHand1401[hand]) : sErr; #endif } /**************************************************************************** ** U14LineCount ** Returns the number of CR characters in the input buffer *****************************************************************************/ U14API(short) U14LineCount(short hand) { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; short sErr = U14Status1401(hand, U14_LINECOUNT, &csBlock); if (sErr == U14ERR_NOERROR) sErr = csBlock.ints[0]; return sErr; #endif #ifdef LINUX short sErr = CheckHandle(hand); return (sErr == U14ERR_NOERROR) ? CED_LineCount(aHand1401[hand]) : sErr; #endif } /**************************************************************************** ** U14GetErrorString ** Converts error code supplied to a decent descriptive string. ** NOTE: This function may use some extra information stored ** internally in the DLL. This information is stored on a ** per-process basis, but it might be altered if you call ** other functions after getting an error and before using ** this function. ****************************************************************************/ U14API(void) U14GetErrorString(short nErr, char* pStr, unsigned short wMax) { char wstr[150]; switch (nErr) /* Basically, we do this with a switch block */ { case U14ERR_OFF: sprintf(wstr, "The 1401 is apparently switched off (code %d)", nErr); break; case U14ERR_NC: sprintf(wstr, "The 1401 is not connected to the interface card (code %d)", nErr); break; case U14ERR_ILL: sprintf(wstr, "The 1401 is not working correctly (code %d)", nErr); break; case U14ERR_NOIF: sprintf(wstr, "The 1401 interface card was not detected (code %d)", nErr); break; case U14ERR_TIME: sprintf(wstr, "The 1401 fails to become ready for use (code %d)", nErr); break; case U14ERR_BADSW: sprintf(wstr, "The 1401 interface card jumpers are incorrect (code %d)", nErr); break; case U14ERR_NOINT: sprintf(wstr, "The 1401 interrupt is not available for use (code %d)", nErr); break; case U14ERR_INUSE: sprintf(wstr, "The 1401 is already in use by another program (code %d)", nErr); break; case U14ERR_NODMA: sprintf(wstr, "The 1401 DMA channel is not available for use (code %d)", nErr); break; case U14ERR_BADHAND: sprintf(wstr, "The application supplied an incorrect 1401 handle (code %d)", nErr); break; case U14ERR_BAD1401NUM: sprintf(wstr, "The application used an incorrect 1401 number (code %d)", nErr); break; case U14ERR_NO_SUCH_FN: sprintf(wstr, "The code passed to the 1401 driver is invalid (code %d)", nErr); break; case U14ERR_NO_SUCH_SUBFN: sprintf(wstr, "The sub-code passed to the 1401 driver is invalid (code %d)", nErr); break; case U14ERR_NOOUT: sprintf(wstr, "No room in buffer for characters for the 1401 (code %d)", nErr); break; case U14ERR_NOIN: sprintf(wstr, "No characters from the 1401 are available (code %d)", nErr); break; case U14ERR_STRLEN: sprintf(wstr, "A string sent to or read from the 1401 was too long (code %d)", nErr); break; case U14ERR_LOCKFAIL: sprintf(wstr, "Failed to lock host memory for data transfer (code %d)", nErr); break; case U14ERR_UNLOCKFAIL: sprintf(wstr, "Failed to unlock host memory after data transfer (code %d)", nErr); break; case U14ERR_ALREADYSET: sprintf(wstr, "The transfer area used is already set up (code %d)", nErr); break; case U14ERR_NOTSET: sprintf(wstr, "The transfer area used has not been set up (code %d)", nErr); break; case U14ERR_BADAREA: sprintf(wstr, "The transfer area number is incorrect (code %d)", nErr); break; case U14ERR_NOFILE: sprintf(wstr, "The command file %s could not be opened (code %d)", szLastName, nErr); break; case U14ERR_READERR: sprintf(wstr, "The command file %s could not be read (code %d)", szLastName, nErr); break; case U14ERR_UNKNOWN: sprintf(wstr, "The %s command resource could not be found (code %d)", szLastName, nErr); break; case U14ERR_HOSTSPACE: sprintf(wstr, "Unable to allocate memory for loading command %s (code %d)", szLastName, nErr); break; case U14ERR_LOCKERR: sprintf(wstr, "Unable to lock memory for loading command %s (code %d)", szLastName, nErr); break; case U14ERR_CLOADERR: sprintf(wstr, "Error in loading command %s, bad command format (code %d)", szLastName, nErr); break; case U14ERR_TOXXXERR: sprintf(wstr, "Error detected after data transfer to or from the 1401 (code %d)", nErr); break; case U14ERR_NO386ENH: sprintf(wstr, "Windows 3.1 is not running in 386 enhanced mode (code %d)", nErr); break; case U14ERR_NO1401DRIV: sprintf(wstr, "The 1401 device driver cannot be found (code %d)\nUSB: check plugged in and powered\nOther: not installed?", nErr); break; case U14ERR_DRIVTOOOLD: sprintf(wstr, "The 1401 device driver is too old for use (code %d)", nErr); break; case U14ERR_TIMEOUT: sprintf(wstr, "Character transmissions to the 1401 timed-out (code %d)", nErr); break; case U14ERR_BUFF_SMALL: sprintf(wstr, "Buffer for text from the 1401 was too small (code %d)", nErr); break; case U14ERR_CBALREADY: sprintf(wstr, "1401 monitor callback already set up (code %d)", nErr); break; case U14ERR_BADDEREG: sprintf(wstr, "1401 monitor callback deregister invalid (code %d)", nErr); break; case U14ERR_DRIVCOMMS: sprintf(wstr, "1401 device driver communications failed (code %d)", nErr); break; case U14ERR_OUTOFMEMORY: sprintf(wstr, "Failed to allocate or lock memory for text from the 1401 (code %d)", nErr); break; default: sprintf(wstr, "1401 error code %d returned; this code is unknown", nErr); break; } if ((unsigned short)strlen(wstr) >= wMax-1) /* Check for string being too long */ wstr[wMax-1] = 0; /* and truncate it if so */ strcpy(pStr, wstr); /* Return the error string */ } /*************************************************************************** ** U14GetTransfer ** Get a TGET_TX_BLOCK describing a transfer area (held in the block) ***************************************************************************/ U14API(short) U14GetTransfer(short hand, TGET_TX_BLOCK *pTransBlock) { short sErr = CheckHandle(hand); #ifdef _IS_WINDOWS_ if (sErr == U14ERR_NOERROR) { unsigned int dwBytes = 0; BOOL bOK = DeviceIoControl(aHand1401[hand], (unsigned int)U14_GETTRANSFER, NULL, 0, pTransBlock, sizeof(TGET_TX_BLOCK), &dwBytes, NULL); if (bOK && (dwBytes >= sizeof(TGET_TX_BLOCK))) sErr = U14ERR_NOERROR; else sErr = U14ERR_DRIVCOMMS; } return sErr; #endif #ifdef LINUX return (sErr == U14ERR_NOERROR) ? CED_GetTransfer(aHand1401[hand], pTransBlock) : sErr; #endif } ///////////////////////////////////////////////////////////////////////////// // U14WorkingSet // For Win32 only, adjusts process working set so that minimum is at least // dwMinKb and maximum is at least dwMaxKb. // Return value is zero if all went OK, or a code from 1 to 3 indicating the // cause of the failure: // // 1 unable to access process (insufficient rights?) // 2 unable to read process working set // 3 unable to set process working set - bad parameters? U14API(short) U14WorkingSet(unsigned int dwMinKb, unsigned int dwMaxKb) { #ifdef _IS_WINDOWS_ short sRetVal = 0; // 0 means all is OK HANDLE hProcess; unsigned int dwVer = GetVersion(); if (dwVer & 0x80000000) // is this not NT? return 0; // then give up right now // Now attempt to get information on working set size hProcess = OpenProcess(STANDARD_RIGHTS_REQUIRED | PROCESS_QUERY_INFORMATION | PROCESS_SET_QUOTA, FALSE, _getpid()); if (hProcess) { SIZE_T dwMinSize,dwMaxSize; if (GetProcessWorkingSetSize(hProcess, &dwMinSize, &dwMaxSize)) { unsigned int dwMin = dwMinKb << 10; // convert from kb to bytes unsigned int dwMax = dwMaxKb << 10; // if we get here, we have managed to read the current size if (dwMin > dwMinSize) // need to change sizes? dwMinSize = dwMin; if (dwMax > dwMaxSize) dwMaxSize = dwMax; if (!SetProcessWorkingSetSize(hProcess, dwMinSize, dwMaxSize)) sRetVal = 3; // failed to change size } else sRetVal = 2; // failed to read original size CloseHandle(hProcess); } else sRetVal = 1; // failed to get handle return sRetVal; #endif #ifdef LINUX if (dwMinKb | dwMaxKb) { // to stop compiler moaning } return U14ERR_NOERROR; #endif } /**************************************************************************** ** U14UnSetTransfer Cancels a transfer area ** wArea The index of a block previously used in by SetTransfer *****************************************************************************/ U14API(short) U14UnSetTransfer(short hand, unsigned short wArea) { short sErr = CheckHandle(hand); #ifdef _IS_WINDOWS_ if (sErr == U14ERR_NOERROR) { TCSBLOCK csBlock; csBlock.ints[0] = (short)wArea; /* Area number into control block */ sErr = U14Control1401(hand, U14_UNSETTRANSFER, &csBlock); /* Free area */ VirtualUnlock(apAreas[hand][wArea], auAreas[hand][wArea]);/* Unlock */ apAreas[hand][wArea] = NULL; /* Clear locations */ auAreas[hand][wArea] = 0; } return sErr; #endif #ifdef LINUX return (sErr == U14ERR_NOERROR) ? CED_UnsetTransfer(aHand1401[hand], wArea) : sErr; #endif } /**************************************************************************** ** U14SetTransArea Sets an area up to be used for transfers ** unsigned short wArea The area number to set up ** void *pvBuff The address of the buffer for the data. ** unsigned int dwLength The length of the buffer for the data ** short eSz The element size (used for byte swapping on the Mac) ****************************************************************************/ U14API(short) U14SetTransArea(short hand, unsigned short wArea, void *pvBuff, unsigned int dwLength, short eSz) { TRANSFERDESC td; short sErr = CheckHandle(hand); if (sErr != U14ERR_NOERROR) return sErr; if (wArea >= MAX_TRANSAREAS) // Is this a valid area number return U14ERR_BADAREA; #ifdef _IS_WINDOWS_ assert(apAreas[hand][wArea] == NULL); assert(auAreas[hand][wArea] == 0); apAreas[hand][wArea] = pvBuff; /* Save data for later */ auAreas[hand][wArea] = dwLength; if (!VirtualLock(pvBuff, dwLength)) /* Lock using WIN32 calls */ { apAreas[hand][wArea] = NULL; /* Clear locations */ auAreas[hand][wArea] = 0; return U14ERR_LOCKERR; /* VirtualLock failed */ } #ifndef _WIN64 if (!USE_NT_DIOC(hand)) /* Use Win 9x DIOC? */ { unsigned int dwBytes; VXTRANSFERDESC vxDesc; /* Structure to pass to VXD */ vxDesc.wArea = wArea; /* Copy across simple params */ vxDesc.dwLength = dwLength; // Check we are not asking an old driver for more than area 0 if ((wArea != 0) && (U14DriverVersion(hand) < 0x00010002L)) sErr = U14ERR_DRIVTOOOLD; else { vxDesc.dwAddrOfs = (unsigned int)pvBuff; /* 32 bit offset */ vxDesc.wAddrSel = 0; if (DeviceIoControl(aHand1401[hand], (unsigned int)U14_SETTRANSFER, pvBuff,dwLength, /* Will translate pointer */ &vxDesc,sizeof(VXTRANSFERDESC), &dwBytes,NULL)) { if (dwBytes >= sizeof(VXTRANSFERDESC)) /* Driver OK ? */ sErr = U14ERR_NOERROR; else sErr = U14ERR_DRIVCOMMS; /* Else never got there */ } else sErr = (short)GetLastError(); } } else #endif { PARAMBLK rWork; unsigned int dwBytes; td.wArea = wArea; /* Pure NT - put data into struct */ td.lpvBuff = pvBuff; td.dwLength = dwLength; td.eSize = 0; // Dummy element size if (DeviceIoControl(aHand1401[hand],(unsigned int)U14_SETTRANSFER, &td,sizeof(TRANSFERDESC), &rWork,sizeof(PARAMBLK),&dwBytes,NULL)) { if (dwBytes >= sizeof(PARAMBLK)) // maybe error from driver? sErr = rWork.sState; // will report any error else sErr = U14ERR_DRIVCOMMS; // Else never got there } else sErr = U14ERR_DRIVCOMMS; } if (sErr != U14ERR_NOERROR) { if (sErr != U14ERR_LOCKERR) // unless lock failed... VirtualUnlock(pvBuff, dwLength); // ...release the lock apAreas[hand][wArea] = NULL; // Clear locations auAreas[hand][wArea] = 0; } return sErr; #endif #ifdef LINUX // The strange cast is so that it works in 64 and 32-bit linux as long is 64-bits // in the 64 bit version. td.lpvBuff = (long long)((unsigned long)pvBuff); td.wAreaNum = wArea; td.dwLength = dwLength; td.eSize = eSz; // Dummy element size return CED_SetTransfer(aHand1401[hand], &td); #endif } /**************************************************************************** ** U14SetTransferEvent Sets an event for notification of application ** wArea The transfer area index, from 0 to MAXAREAS-1 ** bEvent True to create an event, false to remove it ** bToHost Set 0 for notification on to1401 tranfers, 1 for ** notification of transfers to the host PC ** dwStart The offset of the sub-area of interest ** dwLength The size of the sub-area of interest ** ** The device driver will set the event supplied to the signalled state ** whenever a DMA transfer to/from the specified area is completed. The ** transfer has to be in the direction specified by bToHost, and overlap ** that part of the whole transfer area specified by dwStart and dwLength. ** It is important that this function is called with bEvent false to release ** the event once 1401 activity is finished. ** ** Returns 1 if an event handle exists, 0 if all OK and no event handle or ** a negative code for an error. ****************************************************************************/ U14API(short) U14SetTransferEvent(short hand, unsigned short wArea, BOOL bEvent, BOOL bToHost, unsigned int dwStart, unsigned int dwLength) { #ifdef _IS_WINDOWS_ TCSBLOCK csBlock; short sErr = U14TransferFlags(hand); // see if we can handle events if (sErr >= U14ERR_NOERROR) // check handle is OK { bEvent = bEvent && ((sErr & U14TF_NOTIFY) != 0); // remove request if we cannot do events if (wArea >= MAX_TRANSAREAS) // Check a valid area... return U14ERR_BADAREA; // ...and bail of not // We can hold an event for each area, so see if we need to change the // state of the event. if ((bEvent != 0) != (aXferEvent[hand] != 0)) // change of event state? { if (bEvent) // want one and none present aXferEvent[hand] = CreateEvent(NULL, FALSE, FALSE, NULL); else { CloseHandle(aXferEvent[hand]); // clear the existing event aXferEvent[hand] = NULL; // and clear handle } } // We have to store the parameters differently for 64-bit operations // because a handle is 64 bits long. The drivers know of this and // handle the information appropriately. #ifdef _WIN64 csBlock.longs[0] = wArea; // Pass paramaters into the driver... if (bToHost != 0) // The direction flag is held in the csBlock.longs[0] |= 0x10000; // upper word of the transfer area value *((HANDLE*)&csBlock.longs[1]) = aXferEvent[hand]; // The event handle is 64-bits csBlock.longs[3] = dwStart; // Thankfully these two remain csBlock.longs[4] = dwLength; // as unsigned 32-bit values #else csBlock.longs[0] = wArea; // pass paramaters into the driver... csBlock.longs[1] = (long)aXferEvent[hand]; // ...especially the event handle csBlock.longs[2] = bToHost; csBlock.longs[3] = dwStart; csBlock.longs[4] = dwLength; #endif sErr = U14Control1401(hand, U14_SETTRANSEVENT, &csBlock); if (sErr == U14ERR_NOERROR) sErr = (short)(aXferEvent[hand] != NULL); // report if we have a flag } return sErr; #endif #ifdef LINUX TRANSFEREVENT te; short sErr = CheckHandle(hand); if (sErr != U14ERR_NOERROR) return sErr; if (wArea >= MAX_TRANSAREAS) // Is this a valid area number return U14ERR_BADAREA; te.wAreaNum = wArea; // copy parameters to the control block te.wFlags = bToHost ? 1 : 0; // bit 0 sets the direction te.dwStart = dwStart; // start offset of the event area te.dwLength = dwLength; // size of the event area te.iSetEvent = bEvent; // in Windows, this creates/destroys the event return CED_SetEvent(aHand1401[hand], &te); #endif } /**************************************************************************** ** U14TestTransferEvent ** Would a U14WaitTransferEvent() call return immediately? return 1 if so, ** 0 if not or a negative code if a problem. ****************************************************************************/ U14API(int) U14TestTransferEvent(short hand, unsigned short wArea) { #ifdef _IS_WINDOWS_ int iErr = CheckHandle(hand); if (iErr == U14ERR_NOERROR) { if (aXferEvent[hand]) // if a handle is set... iErr = WaitForSingleObject(aXferEvent[hand], 0) == WAIT_OBJECT_0; } return iErr; #endif #ifdef LINUX short sErr = CheckHandle(hand); return (sErr == U14ERR_NOERROR) ? CED_TestEvent(aHand1401[hand], wArea) : sErr; #endif } /**************************************************************************** ** U14WaitTransferEvent ** Wait for a transfer event with a timeout. ** msTimeOut is 0 for an infinite wait, else it is the maximum time to wait ** in milliseconds in range 0-0x00ffffff. ** Returns If no event handle then return immediately. Else return 1 if ** timed out or 0=event, and a negative code if a problem. ****************************************************************************/ U14API(int) U14WaitTransferEvent(short hand, unsigned short wArea, int msTimeOut) { #ifdef _IS_WINDOWS_ int iErr = CheckHandle(hand); if (iErr == U14ERR_NOERROR) { if (aXferEvent[hand]) { if (msTimeOut == 0) msTimeOut = INFINITE; iErr = WaitForSingleObject(aXferEvent[hand], msTimeOut) != WAIT_OBJECT_0; } else iErr = TRUE; // say we timed out if no event } return iErr; #endif #ifdef LINUX short sErr = CheckHandle(hand); return (sErr == U14ERR_NOERROR) ? CED_WaitEvent(aHand1401[hand], wArea, msTimeOut) : sErr; #endif } /**************************************************************************** ** U14SetCircular Sets an area up for circular DMA transfers ** unsigned short wArea The area number to set up ** BOOL bToHost Sets the direction of data transfer ** void *pvBuff The address of the buffer for the data ** unsigned int dwLength The length of the buffer for the data ****************************************************************************/ U14API(short) U14SetCircular(short hand, unsigned short wArea, BOOL bToHost, void *pvBuff, unsigned int dwLength) { short sErr = CheckHandle(hand); if (sErr != U14ERR_NOERROR) return sErr; if (wArea >= MAX_TRANSAREAS) /* Is this a valid area number */ return U14ERR_BADAREA; if (!bToHost) /* For now, support tohost transfers only */ return U14ERR_BADAREA; /* best error code I can find */ #ifdef _IS_WINDOWS_ assert(apAreas[hand][wArea] == NULL); assert(auAreas[hand][wArea] == 0); apAreas[hand][wArea] = pvBuff; /* Save data for later */ auAreas[hand][wArea] = dwLength; if (!VirtualLock(pvBuff, dwLength)) /* Lock using WIN32 calls */ sErr = U14ERR_LOCKERR; /* VirtualLock failed */ else { PARAMBLK rWork; unsigned int dwBytes; TRANSFERDESC txDesc; txDesc.wArea = wArea; /* Pure NT - put data into struct */ txDesc.lpvBuff = pvBuff; txDesc.dwLength = dwLength; txDesc.eSize = (short)bToHost; /* Use this for direction flag */ if (DeviceIoControl(aHand1401[hand],(unsigned int)U14_SETCIRCULAR, &txDesc, sizeof(TRANSFERDESC), &rWork, sizeof(PARAMBLK),&dwBytes,NULL)) { if (dwBytes >= sizeof(PARAMBLK)) /* error from driver? */ sErr = rWork.sState; /* No, just return driver data */ else sErr = U14ERR_DRIVCOMMS; /* Else never got there */ } else sErr = U14ERR_DRIVCOMMS; } if (sErr != U14ERR_NOERROR) { if (sErr != U14ERR_LOCKERR) VirtualUnlock(pvBuff, dwLength); /* Release NT lock */ apAreas[hand][wArea] = NULL; /* Clear locations */ auAreas[hand][wArea] = 0; } return sErr; #endif #ifdef LINUX else { TRANSFERDESC td; td.lpvBuff = (long long)((unsigned long)pvBuff); td.wAreaNum = wArea; td.dwLength = dwLength; td.eSize = (short)bToHost; /* Use this for direction flag */ return CED_SetCircular(aHand1401[hand], &td); } #endif } /**************************************************************************** ** Function GetCircBlk returns the size (& start offset) of the next ** available block of circular data. ****************************************************************************/ U14API(int) U14GetCircBlk(short hand, unsigned short wArea, unsigned int *pdwOffs) { int lErr = CheckHandle(hand); if (lErr != U14ERR_NOERROR) return lErr; if (wArea >= MAX_TRANSAREAS) // Is this a valid area number? return U14ERR_BADAREA; else { #ifdef _IS_WINDOWS_ PARAMBLK rWork; TCSBLOCK csBlock; unsigned int dwBytes; csBlock.longs[0] = wArea; // Area number into control block rWork.sState = U14ERR_DRIVCOMMS; if (DeviceIoControl(aHand1401[hand], (unsigned int)U14_GETCIRCBLK, &csBlock, sizeof(TCSBLOCK), &rWork, sizeof(PARAMBLK), &dwBytes, NULL) && (dwBytes >= sizeof(PARAMBLK))) lErr = rWork.sState; else lErr = U14ERR_DRIVCOMMS; if (lErr == U14ERR_NOERROR) // Did everything go OK? { // Yes, we can pass the results back lErr = rWork.csBlock.longs[1]; // Return the block information *pdwOffs = rWork.csBlock.longs[0]; // Offset is first in array } #endif #ifdef LINUX TCIRCBLOCK cb; cb.nArea = wArea; // Area number into control block cb.dwOffset = 0; cb.dwSize = 0; lErr = CED_GetCircBlock(aHand1401[hand], &cb); if (lErr == U14ERR_NOERROR) // Did everything go OK? { // Yes, we can pass the results back lErr = cb.dwSize; // return the size *pdwOffs = cb.dwOffset; // and the offset } #endif } return lErr; } /**************************************************************************** ** Function FreeCircBlk marks the specified area of memory as free for ** resuse for circular transfers and returns the size (& start ** offset) of the next available block of circular data. ****************************************************************************/ U14API(int) U14FreeCircBlk(short hand, unsigned short wArea, unsigned int dwOffs, unsigned int dwSize, unsigned int *pdwOffs) { int lErr = CheckHandle(hand); if (lErr != U14ERR_NOERROR) return lErr; if (wArea < MAX_TRANSAREAS) // Is this a valid area number { #ifdef _IS_WINDOWS_ PARAMBLK rWork; TCSBLOCK csBlock; unsigned int dwBytes; csBlock.longs[0] = wArea; // Area number into control block csBlock.longs[1] = dwOffs; csBlock.longs[2] = dwSize; rWork.sState = U14ERR_DRIVCOMMS; if (DeviceIoControl(aHand1401[hand], (unsigned int)U14_FREECIRCBLK, &csBlock, sizeof(TCSBLOCK), &rWork, sizeof(PARAMBLK), &dwBytes, NULL) && (dwBytes >= sizeof(PARAMBLK))) lErr = rWork.sState; else lErr = U14ERR_DRIVCOMMS; if (lErr == U14ERR_NOERROR) // Did everything work OK? { // Yes, we can pass the results back lErr = rWork.csBlock.longs[1]; // Return the block information *pdwOffs = rWork.csBlock.longs[0]; // Offset is first in array } #endif #ifdef LINUX TCIRCBLOCK cb; cb.nArea = wArea; // Area number into control block cb.dwOffset = dwOffs; cb.dwSize = dwSize; lErr = CED_FreeCircBlock(aHand1401[hand], &cb); if (lErr == U14ERR_NOERROR) // Did everything work OK? { // Yes, we can pass the results back lErr = cb.dwSize; // Return the block information *pdwOffs = cb.dwOffset; // Offset is first in array } #endif } else lErr = U14ERR_BADAREA; return lErr; } /**************************************************************************** ** Transfer ** Transfer moves data to 1401 or to host ** Assumes memory is allocated and locked, ** which it should be to get a pointer *****************************************************************************/ static short Transfer(short hand, BOOL bTo1401, char* pData, unsigned int dwSize, unsigned int dw1401, short eSz) { char strcopy[MAXSTRLEN+1]; // to hold copy of work string short sResult = U14SetTransArea(hand, 0, (void *)pData, dwSize, eSz); if (sResult == U14ERR_NOERROR) // no error { sprintf(strcopy, // data offset is always 0 "TO%s,$%X,$%X,0;", bTo1401 ? "1401" : "HOST", dw1401, dwSize); U14SendString(hand, strcopy); // send transfer string sResult = U14CheckErr(hand); // Use ERR command to check for done if (sResult > 0) sResult = U14ERR_TOXXXERR; // If a 1401 error, use this code U14UnSetTransfer(hand, 0); } return sResult; } /**************************************************************************** ** Function ToHost transfers data into the host from the 1401 ****************************************************************************/ U14API(short) U14ToHost(short hand, char* pAddrHost, unsigned int dwSize, unsigned int dw1401, short eSz) { short sErr = CheckHandle(hand); if ((sErr == U14ERR_NOERROR) && dwSize) // TOHOST is a constant sErr = Transfer(hand, TOHOST, pAddrHost, dwSize, dw1401, eSz); return sErr; } /**************************************************************************** ** Function To1401 transfers data into the 1401 from the host ****************************************************************************/ U14API(short) U14To1401(short hand, const char* pAddrHost,unsigned int dwSize, unsigned int dw1401, short eSz) { short sErr = CheckHandle(hand); if ((sErr == U14ERR_NOERROR) && dwSize) // TO1401 is a constant sErr = Transfer(hand, TO1401, (char*)pAddrHost, dwSize, dw1401, eSz); return sErr; } /**************************************************************************** ** Function LdCmd Loads a command from a full path or just a file *****************************************************************************/ #ifdef _IS_WINDOWS_ #define file_exist(name) (_access(name, 0) != -1) #define file_open(name) _lopen(name, OF_READ) #define file_close(h) _lclose(h) #define file_seek(h, pos) _llseek(h, pos, FILE_BEGIN) #define file_read(h, buffer, size) (_lread(h, buffer, size) == size) #endif #ifdef LINUX #define file_exist(name) (access(name, F_OK) != -1) #define file_open(name) open(name, O_RDONLY) #define file_close(h) close(h) #define file_seek(h, pos) lseek(h, pos, SEEK_SET) #define file_read(h, buffer, size) (read(h, buffer, size) == (ssize_t)size) static unsigned int GetModuleFileName(void* dummy, char* buffer, int max) { // The following works for Linux systems with a /proc file system. char szProcPath[32]; sprintf(szProcPath, "/proc/%d/exe", getpid()); // attempt to read link if (readlink(szProcPath, buffer, max) != -1) { dirname (buffer); strcat (buffer, "/"); return strlen(buffer); } return 0; } #endif U14API(short) U14LdCmd(short hand, const char* command) { char strcopy[MAXSTRLEN+1]; // to hold copy of work string BOOL bGotIt = FALSE; // have we found the command file? int iFHandle; // file handle of command #define FNSZ 260 char filnam[FNSZ]; // space to build name in char szCmd[25]; // just the command name with extension short sErr = CheckHandle(hand); if (sErr != U14ERR_NOERROR) return sErr; if (strchr(command, '.') != NULL) // see if we have full name { if (file_exist(command)) // If the file exists { strcpy(filnam, command); // use name as is bGotIt = TRUE; // Flag no more searching } else // not found, get file name for search { char* pStr = strrchr(command, PATHSEP); // Point to last separator if (pStr != NULL) // Check we got it { pStr++; // move past the backslash strcpy(szCmd, pStr); // copy file name as is } else strcpy(szCmd, command); // use as is } } else // File extension not supplied, so build the command file name { char szExt[8]; strcpy(szCmd, command); // Build command file name ExtForType(asType1401[hand], szExt);// File extension string strcat(szCmd, szExt); // add it to the end } // Next place to look is in the 1401 folder in the same place as the // application was run from. if (!bGotIt) // Still not got it? { unsigned int dwLen = GetModuleFileName(NULL, filnam, FNSZ); // Get app path if (dwLen > 0) // and use it as path if found { char* pStr = strrchr(filnam, PATHSEP); // Point to last separator if (pStr != NULL) { *(++pStr) = 0; // Terminate string there if (strlen(filnam) < FNSZ-6) // make sure we have space { strcat(filnam, "1401" PATHSEPSTR); // add in 1401 subdir strcat(filnam,szCmd); bGotIt = (BOOL)file_exist(filnam); // See if file exists } } } } // Next place to look is in whatever path is set by the 1401DIR environment // variable, if it exists. if (!bGotIt) // Need to do more searches?/ { char* pStr = getenv("1401DIR"); // Try to find environment var if (pStr != NULL) // and use it as path if found { strcpy(filnam, pStr); // Use path in environment if (filnam[strlen(filnam)-1] != PATHSEP)// We need separator strcat(filnam, PATHSEPSTR); strcat(filnam, szCmd); bGotIt = (BOOL)file_exist(filnam); // Got this one? } } // Last place to look is the default location. if (!bGotIt) // Need to do more searches? { strcpy(filnam, DEFCMDPATH); // Use default path strcat(filnam, szCmd); bGotIt = file_exist(filnam); // Got this one? } iFHandle = file_open(filnam); if (iFHandle == -1) sErr = U14ERR_NOFILE; else { // first read in the header block CMDHEAD rCmdHead; // to hold the command header if (file_read(iFHandle, &rCmdHead, sizeof(CMDHEAD))) { size_t nComSize = rCmdHead.wCmdSize; char* pMem = malloc(nComSize); if (pMem != NULL) { file_seek(iFHandle, sizeof(CMDHEAD)); if (file_read(iFHandle, pMem, (UINT)nComSize)) { sErr = U14SetTransArea(hand, 0, (void *)pMem, (unsigned int)nComSize, ESZBYTES); if (sErr == U14ERR_NOERROR) { sprintf(strcopy, "CLOAD,0,$%X;", (int)nComSize); sErr = U14SendString(hand, strcopy); if (sErr == U14ERR_NOERROR) { sErr = U14CheckErr(hand); // Use ERR to check for done if (sErr > 0) sErr = U14ERR_CLOADERR; // If an error, this code } U14UnSetTransfer(hand, 0); // release transfer area } } else sErr = U14ERR_READERR; free(pMem); } else sErr = U14ERR_HOSTSPACE; // memory allocate failed } else sErr = U14ERR_READERR; file_close(iFHandle); // close the file } return sErr; } /**************************************************************************** ** Ld ** Loads a command into the 1401 ** Returns NOERROR code or a long with error in lo word and index of ** command that failed in high word ****************************************************************************/ U14API(unsigned int) U14Ld(short hand, const char* vl, const char* str) { unsigned int dwIndex = 0; // index to current command long lErr = U14ERR_NOERROR; // what the error was that went wrong char strcopy[MAXSTRLEN+1]; // stores unmodified str parameter char szFExt[8]; // The command file extension short sErr = CheckHandle(hand); if (sErr != U14ERR_NOERROR) return sErr; ExtForType(asType1401[hand], szFExt); // File extension string strcpy(strcopy, str); // to avoid changing original // now break out one command at a time and see if loaded if (*str) // if anything there { BOOL bDone = FALSE; // true when finished all commands int iLoop1 = 0; // Point at start of string for command name int iLoop2 = 0; // and at start of str parameter do // repeat until end of str { char filnam[MAXSTRLEN+1]; // filename to use char szFName[MAXSTRLEN+1]; // filename work string if (!strcopy[iLoop1]) // at the end of the string? bDone = TRUE; // set the finish flag if (bDone || (strcopy[iLoop1] == ',')) // end of cmd? { U14LONG er[5]; // Used to read back error results ++dwIndex; // Keep count of command number, first is 1 szFName[iLoop2]=(char)0; // null terminate name of command strncpy(szLastName, szFName, sizeof(szLastName)); // Save for error info szLastName[sizeof(szLastName)-1] = 0; strncat(szLastName, szFExt, sizeof(szLastName)); // with extension included szLastName[sizeof(szLastName)-1] = 0; U14SendString(hand, szFName); // ask if loaded U14SendString(hand, ";ERR;"); // add err return lErr = U14LongsFrom1401(hand, er, 5); if (lErr > 0) { lErr = U14ERR_NOERROR; if (er[0] == 255) // if command not loaded at all { if (vl && *vl) // if we have a path name { strcpy(filnam, vl); if (strchr("\\/:", filnam[strlen(filnam)-1]) == NULL) strcat(filnam, PATHSEPSTR); // add separator if none found strcat(filnam, szFName); // add the file name strcat(filnam, szFExt); // and extension } else strcpy(filnam, szFName); // simple name lErr = U14LdCmd(hand, filnam); // load cmd if (lErr != U14ERR_NOERROR) // spot any errors bDone = TRUE; // give up if an error } } else bDone = TRUE; // give up if an error iLoop2 = 0; // Reset pointer to command name string ++iLoop1; // and move on through str parameter } else szFName[iLoop2++] = strcopy[iLoop1++]; // no command end, so copy 1 char } while (!bDone); } if (lErr == U14ERR_NOERROR) { szLastName[0] = 0; // No error, so clean out command name here return lErr; } else return ((dwIndex<<16) | ((unsigned int)lErr & 0x0000FFFF)); } // Initialise the library (if not initialised) and return the library version U14API(int) U14InitLib(void) { int iRetVal = U14LIB_VERSION; if (iAttached == 0) // only do this the first time please { int i; #ifdef _IS_WINDOWS_ int j; unsigned int dwVersion = GetVersion(); bWindows9x = FALSE; // Assume not Win9x if (dwVersion & 0x80000000) // if not windows NT { if ((LOBYTE(LOWORD(dwVersion)) < 4) && // if Win32s or... (HIBYTE(LOWORD(dwVersion)) < 95)) // ...below Windows 95 iRetVal = 0; // We do not support this else bWindows9x = TRUE; // Flag we have Win9x } #endif for (i = 0; i < MAX1401; i++) // initialise the device area { aHand1401[i] = INVALID_HANDLE_VALUE; // Clear handle values asType1401[i] = U14TYPEUNKNOWN; // and 1401 type codes alTimeOutPeriod[i] = 3000; // 3 second timeouts #ifdef _IS_WINDOWS_ #ifndef _WIN64 abUseNTDIOC[i] = (BOOL)!bWindows9x; #endif aXferEvent[i] = NULL; // there are no Xfer events for (j = 0; j < MAX_TRANSAREAS; j++) // Clear out locked area info { apAreas[i][j] = NULL; auAreas[i][j] = 0; } #endif } } return iRetVal; } ///-------------------------------------------------------------------------------- /// Functions called when the library is loaded and unloaded to give us a chance to /// setup the library. #ifdef _IS_WINDOWS_ #ifndef U14_NOT_DLL /**************************************************************************** ** FUNCTION: DllMain(HANDLE, unsigned int, LPVOID) ** LibMain is called by Windows when the DLL is initialized, Thread Attached, ** and other times. Refer to SDK documentation, as to the different ways this ** may be called. ****************************************************************************/ INT APIENTRY DllMain(HANDLE hInst, unsigned int ul_reason_being_called, LPVOID lpReserved) { int iRetVal = 1; switch (ul_reason_being_called) { case DLL_PROCESS_ATTACH: iRetVal = U14InitLib() > 0; // does nothing if iAttached != 0 ++iAttached; // count times attached break; case DLL_PROCESS_DETACH: if (--iAttached == 0) // last man out? U14CloseAll(); // release all open handles break; } return iRetVal; UNREFERENCED_PARAMETER(lpReserved); } #endif #endif #ifdef LINUX void __attribute__((constructor)) use1401_load(void) { U14InitLib(); ++iAttached; } void __attribute__((destructor)) use1401_unload(void) { if (--iAttached == 0) // last man out? U14CloseAll(); // release all open handles } #endif