Google Git
Sign in
nest-open-source / nest-hello / linux-3.10 / 88783dd411e691fbf66594cb7832185bb08e3d3e / . / drivers / staging / ced1401 / userspace / use1401.c
blob: 38e7c1c82d43d7b1fc7de392c7fad47aef9e295e [file] [log] [blame]
/****************************************************************************
** 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 DWORD 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 <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "USE1401.H"
#ifdef _IS_WINDOWS_
#include <io.h>
#include <windows.h>
#pragma warning(disable: 4100) /* Disable "Unused formal parameter" warning */
#include <assert.h>
#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 <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <sys/time.h>
#include <sched.h>
#include <libgen.h>
#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 DWORD 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
WORD wBasicSz; // size as seen by BASIC
WORD 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)
{
DWORD 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)
{
DWORD 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)
{
WORD 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, WORD 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, DWORD 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, DWORD dwAddr, DWORD 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, DWORD dwAddr, DWORD dwDef, DWORD 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, DWORD dwDef, DWORD 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, DWORD *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, WORD 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;
DWORD 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
{
DWORD 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<MAX_TRANSAREAS; ++j)
{
TGET_TX_BLOCK gtb;
int iReturn = U14GetTransfer(hand, &gtb); // get area information
if (iReturn == U14ERR_NOERROR) // ignore if any problem
if (gtb.used)
iAreaMask |= (1 << j); // set a bit for each used area
}
if (iAreaMask) // if any areas are in use
{
U14Reset1401(hand); // in case an active transfer running
for (j = 0; j < MAX_TRANSAREAS; ++j) // Locate locked areas
if (iAreaMask & (1 << j)) // And kill off any transfers
U14UnSetTransfer(hand, (WORD)j);
}
#ifdef _IS_WINDOWS_
if (aXferEvent[hand]) // if this 1401 has an open event handle
{
CloseHandle(aXferEvent[hand]); // close down the handle
aXferEvent[hand] = NULL; // and mark it as gone
}
if (CloseHandle(aHand1401[hand]))
#endif
#ifdef LINUX
if (close(aHand1401[hand]) == 0) // make sure that close works
#endif
{
aHand1401[hand] = INVALID_HANDLE_VALUE;
asType1401[hand] = U14TYPEUNKNOWN;
return U14ERR_NOERROR;
}
else
return U14ERR_BADHAND; /* BUGBUG GetLastError() ? */
}
/**************************************************************************
**
** Look for open 1401s and attempt to close them down. 32-bit windows only.
**************************************************************************/
U14API(void) U14CloseAll(void)
{
int i;
for (i = 0; i < MAX1401; i++) // Tidy up and make safe
if (aHand1401[i] != INVALID_HANDLE_VALUE)
U14Close1401((short)i); // Last ditch close 1401
}
/****************************************************************************
** U14Reset1401
** Resets the 1401
****************************************************************************/
U14API(short) U14Reset1401(short hand)
{
#ifdef _IS_WINDOWS_
TCSBLOCK csBlock;
return U14Control1401(hand, U14_RESET1401, &csBlock);
#endif
#ifdef LINUX
short sErr = CheckHandle(hand);
return (sErr == U14ERR_NOERROR) ? CED_Reset1401(aHand1401[hand]) : sErr;
#endif
}
/****************************************************************************
** U14ForceReset
** Sets the 1401 full reset flag, so that next call to Reset1401 will
** always cause a genuine reset.
*****************************************************************************/
U14API(short) U14ForceReset(short hand)
{
#ifdef _IS_WINDOWS_
TCSBLOCK csBlock;
return U14Control1401(hand, U14_FULLRESET, &csBlock);
#endif
#ifdef LINUX
short sErr = CheckHandle(hand);
return (sErr == U14ERR_NOERROR) ? CED_FullReset(aHand1401[hand]) : sErr;
#endif
}
/****************************************************************************
** U14KillIO1401
** Removes any pending IO from the buffers.
*****************************************************************************/
U14API(short) U14KillIO1401(short hand)
{
#ifdef _IS_WINDOWS_
TCSBLOCK csBlock;
return U14Control1401(hand, U14_KILLIO1401, &csBlock);
#endif
#ifdef LINUX
short sErr = CheckHandle(hand);
return (sErr == U14ERR_NOERROR) ? CED_KillIO1401(aHand1401[hand]) : sErr;
#endif
}
/****************************************************************************
** U14SendString
** Send characters to the 1401
*****************************************************************************/
U14API(short) U14SendString(short hand, const char* pString)
{
int nChars; // length we are sending
long lTimeOutTicks; // when to time out
BOOL bSpaceToSend; // space to send yet
short sErr = CheckHandle(hand);
if (sErr != U14ERR_NOERROR)
return sErr;
nChars = (int)strlen(pString); // get string length we want to send
if (nChars > 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;
DWORD 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], (DWORD)U14_SENDSTRING,
NULL, 0, tstr, nChars,
&dwBytes, NULL);
if (iOK)
sErr = (dwBytes >= (DWORD)nChars) ? U14ERR_NOERROR : U14ERR_DRIVCOMMS;
else
sErr = (short)GetLastError();
}
else
#endif
{
int iOK = DeviceIoControl(aHand1401[hand],(DWORD)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, WORD 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 */
{
DWORD dwBytes = 0;
*((WORD *)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;
*((WORD *)tstr) = wMaxLen; /* set len */
iOK = DeviceIoControl(aHand1401[hand],(DWORD)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],(DWORD)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, WORD 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 ((WORD)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)
{
DWORD dwBytes = 0;
BOOL bOK = DeviceIoControl(aHand1401[hand], (DWORD)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(DWORD dwMinKb, DWORD dwMaxKb)
{
#ifdef _IS_WINDOWS_
short sRetVal = 0; // 0 means all is OK
HANDLE hProcess;
DWORD 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))
{
DWORD dwMin = dwMinKb << 10; // convert from kb to bytes
DWORD 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, WORD 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
** WORD wArea The area number to set up
** void *pvBuff The address of the buffer for the data.
** DWORD 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, WORD wArea, void *pvBuff,
DWORD 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? */
{
DWORD 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 = (DWORD)pvBuff; /* 32 bit offset */
vxDesc.wAddrSel = 0;
if (DeviceIoControl(aHand1401[hand], (DWORD)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;
DWORD 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],(DWORD)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, WORD wArea, BOOL bEvent,
BOOL bToHost, DWORD dwStart, DWORD 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, WORD 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, WORD 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
** WORD 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
** DWORD dwLength The length of the buffer for the data
****************************************************************************/
U14API(short) U14SetCircular(short hand, WORD wArea, BOOL bToHost,
void *pvBuff, DWORD 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;
DWORD 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],(DWORD)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, WORD wArea, DWORD *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;
DWORD dwBytes;
csBlock.longs[0] = wArea; // Area number into control block
rWork.sState = U14ERR_DRIVCOMMS;
if (DeviceIoControl(aHand1401[hand], (DWORD)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, WORD wArea, DWORD dwOffs, DWORD dwSize,
DWORD *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;
DWORD 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], (DWORD)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,
DWORD dwSize, DWORD 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, DWORD dwSize,
DWORD 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,DWORD dwSize,
DWORD 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 DWORD 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?
{
DWORD 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, (DWORD)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(DWORD) U14Ld(short hand, const char* vl, const char* str)
{
DWORD 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) | ((DWORD)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;
DWORD 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, DWORD, 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, DWORD 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