/**************************************************
* scalerISRSetup()
***************************************************/
STATIC int scalerISRSetup(int card)
{
long status;
volatile char *addr;
int intLevel;
Debug(5, "scalerISRSetup: Entry, card #%d\n", card);
if ((card+1) > scaler_total_cards) return(ERROR);
addr = scaler_state[card]->localAddr;
status = devConnectInterrupt(intVME, vsc_InterruptVector + card,
(void *) &scalerISR, (void *) card);
if (!RTN_SUCCESS(status)) {
errPrintf(status, __FILE__, __LINE__, "Can't connect to vector %ld\n",
vsc_InterruptVector + card);
return (ERROR);
}
/* get interrupt level from hardware, and enable that level in EPICS */
intLevel = readReg16(addr,IRQ_LEVEL_ENABLE_OFFSET) & 5 /*3*/;
Debug(5, "scalerISRSetup: Interrupt level %d\n", intLevel);
status = devEnableInterruptLevel(intVME, intLevel);
if (!RTN_SUCCESS(status)) {
errPrintf(status, __FILE__, __LINE__,
"Can't enable enterrupt level %d\n", intLevel);
return (ERROR);
}
/* Write interrupt vector to hardware */
writeReg16(addr,IRQ_VECTOR_OFFSET,(unsigned short) (vsc_InterruptVector + card));
Debug(5, "scalerISRSetup: Exit, card #%d\n", card);
return (OK);
}
static void destroyAllChannels (
struct client * client, ELLLIST * pList )
{
if ( !client->chanListLock || !client->eventqLock ) {
return;
}
while ( TRUE ) {
struct event_ext *pevext;
int status;
struct channel_in_use *pciu;
epicsMutexMustLock ( client->chanListLock );
pciu = (struct channel_in_use *) ellGet ( pList );
epicsMutexUnlock ( client->chanListLock );
if ( ! pciu ) {
break;
}
while ( TRUE ) {
/*
* AS state change could be using this list
*/
epicsMutexMustLock ( client->eventqLock );
pevext = (struct event_ext *) ellGet ( &pciu->eventq );
epicsMutexUnlock ( client->eventqLock );
if ( ! pevext ) {
break;
}
if ( pevext->pdbev ) {
db_cancel_event (pevext->pdbev);
}
freeListFree (rsrvEventFreeList, pevext);
}
rsrvFreePutNotify ( client, pciu->pPutNotify );
LOCK_CLIENTQ;
status = bucketRemoveItemUnsignedId ( pCaBucket, &pciu->sid);
rsrvChannelCount--;
UNLOCK_CLIENTQ;
if ( status != S_bucket_success ) {
errPrintf ( status, __FILE__, __LINE__,
"Bad id=%d at close", pciu->sid);
}
status = asRemoveClient(&pciu->asClientPVT);
if ( status && status != S_asLib_asNotActive ) {
printf ( "bad asRemoveClient() status was %x \n", status );
errPrintf ( status, __FILE__, __LINE__, "asRemoveClient" );
}
freeListFree ( rsrvChanFreeList, pciu );
}
}
static int sendOnly(MM4000Controller *pController, char *outputBuff)
{
size_t nRequested=strlen(outputBuff);
size_t nActual;
asynStatus status;
if (pController->pasynUser == NULL)
{
status = asynError;
errPrintf(-1, __FILE__, __LINE__, "*** Configuration error ***: pasynUser=NULL\n");
epicsThreadSleep(5.0);
}
else
{
status = pasynOctetSyncIO->write(pController->pasynUser, outputBuff,
nRequested, TIMEOUT, &nActual);
if (nActual != nRequested)
status = asynError;
if (status != asynSuccess)
{
asynPrint(pController->pasynUser, ASYN_TRACE_ERROR,
"drvMM4000Asyn:sendOnly: error sending command %s, sent=%d, status=%d\n",
outputBuff, nActual, status);
}
}
return(status);
}
/*
* report_conflict()
*/
static void report_conflict (
epicsAddressType addrType,
size_t base,
size_t size,
const char *pOwnerName
)
{
const rangeItem *pRange;
errPrintf (
S_dev_addressOverlap,
__FILE__,
__LINE__,
"%10s 0X%08X - OX%08X Requested by %s",
epicsAddressTypeName[addrType],
(unsigned int)base,
(unsigned int)(base+size-1),
pOwnerName);
pRange = (rangeItem *) ellFirst(&addrAlloc[addrType]);
while (pRange) {
if (pRange->begin <= base + (size-1) && pRange->end >= base) {
report_conflict_device (addrType, pRange);
}
pRange = (rangeItem *) pRange->node.next;
}
}
caStatus casAsyncPVExistIOI::cbFuncAsyncIO (
epicsGuard < casClientMutex > & guard )
{
caStatus status;
if ( this->msg.m_cmmd == CA_PROTO_SEARCH ) {
//
// pass output DG address parameters
//
status = this->client.asyncSearchResponse (
guard, this->dgOutAddr, this->msg, this->retVal,
this->protocolRevision, this->sequenceNumber );
}
else {
errPrintf ( S_cas_invalidAsynchIO, __FILE__, __LINE__,
" - client request type = %u", this->msg.m_cmmd );
status = S_cas_invalidAsynchIO;
}
if ( status != S_cas_sendBlocked ) {
this->client.uninstallAsynchIO ( *this );
this->client.getCAS().decrementIOInProgCount ();
}
return status;
}
static int db_yyinput(char *buf, int max_size)
{
int l,n;
char *fgetsRtn;
if(yyAbort) return(0);
if(*my_buffer_ptr==0) {
while(TRUE) { /*until we get some input*/
if(macHandle) {
fgetsRtn = fgets(mac_input_buffer,MY_BUFFER_SIZE,
pinputFileNow->fp);
if(fgetsRtn) {
n = macExpandString(macHandle,mac_input_buffer,
my_buffer,MY_BUFFER_SIZE);
if(n<0) {
errPrintf(0,__FILE__, __LINE__,
"macExpandString failed for file %s",
pinputFileNow->filename);
}
}
} else {
fgetsRtn = fgets(my_buffer,MY_BUFFER_SIZE,pinputFileNow->fp);
}
if(fgetsRtn) break;
if(fclose(pinputFileNow->fp))
errPrintf(0,__FILE__, __LINE__,
"Closing file %s",pinputFileNow->filename);
free((void *)pinputFileNow->filename);
ellDelete(&inputFileList,(ELLNODE *)pinputFileNow);
free((void *)pinputFileNow);
pinputFileNow = (inputFile *)ellLast(&inputFileList);
if(!pinputFileNow) return(0);
}
if(dbStaticDebug) fprintf(stderr,"%s",my_buffer);
pinputFileNow->line_num++;
my_buffer_ptr = &my_buffer[0];
}
l = strlen(my_buffer_ptr);
n = (l<=max_size ? l : max_size);
memcpy(buf,my_buffer_ptr,n);
my_buffer_ptr += n;
return(n);
}
/**************************************************
* scalerEndOfGateISRSetup()
***************************************************/
STATIC int scalerEndOfGateISRSetup(int card)
{
long status;
volatile char *addr;
volatile uint16 u16;
Debug(5, "scalerEndOfGateISRSetup: Entry, card #%d\n", card);
if (card >= scalerVS_total_cards) return(ERROR);
addr = scalerVS_state[card]->localAddr;
status = devConnectInterruptVME(vs_InterruptVector + card,
(void *) &scalerEndOfGateISR, (void *)card);
if (!RTN_SUCCESS(status)) {
errPrintf(status, __FILE__, __LINE__, "Can't connect to vector %d\n",
vs_InterruptVector + card);
return (ERROR);
}
/* write interrupt level to hardware, and tell EPICS to enable that level */
u16 = readReg16(addr,IRQ_SETUP_OFFSET) & 0x0ff;
/* OR in level for end-of-gate interrupt */
writeReg16(addr,IRQ_SETUP_OFFSET, u16 | (vs_InterruptLevel << 8));
status = devEnableInterruptLevelVME(vs_InterruptLevel);
if (!RTN_SUCCESS(status)) {
errPrintf(status, __FILE__, __LINE__,
"Can't enable enterrupt level %d\n", vs_InterruptLevel);
return (ERROR);
}
Debug(5, "scalerEndOfGateISRSetup: Wrote interrupt level, %d, to hardware\n",
vs_InterruptLevel);
/* Write interrupt vector to hardware */
writeReg16(addr,IRQ_3_GATE_VECTOR_OFFSET, (uint16)(vs_InterruptVector + card));
Debug(5, "scalerEndOfGateISRSetup: Wrote interrupt vector, %d, to hardware\n",
vs_InterruptVector + card);
Debug(5, "scalerEndOfGateISRSetup: Read interrupt vector, %d, from hardware\n",
readReg16(addr,IRQ_3_GATE_VECTOR_OFFSET) & 0x0ff);
Debug(5, "scalerEndOfGateISRSetup: Exit, card #%d\n", card);
return (OK);
}
void recGblRecordError(long status, void *pdbc,
const char *pmessage)
{
dbCommon *precord = pdbc;
errPrintf(status,0,0,
"PV: %s %s\n",
(precord ? precord->name : "Unknown"),
(pmessage ? pmessage : ""));
return;
}
/*
* report_conflict_device()
*/
static void report_conflict_device(epicsAddressType addrType, const rangeItem *pRange)
{
errPrintf (
S_dev_identifyOverlap,
__FILE__,
__LINE__,
"%10s 0X%08X - 0X%08X Owned by %s",
epicsAddressTypeName[addrType],
(unsigned int)pRange->begin,
(unsigned int)pRange->end,
pRange->pOwnerName);
}
static void freeInputFileList(void)
{
inputFile *pinputFileNow;
while((pinputFileNow=(inputFile *)ellFirst(&inputFileList))) {
if(fclose(pinputFileNow->fp))
errPrintf(0,__FILE__, __LINE__,
"Closing file %s",pinputFileNow->filename);
free((void *)pinputFileNow->filename);
ellDelete(&inputFileList,(ELLNODE *)pinputFileNow);
free((void *)pinputFileNow);
}
}
/*
* devBusToLocalAddr()
*/
long devBusToLocalAddr(
epicsAddressType addrType,
size_t busAddr,
volatile void **ppLocalAddress)
{
long status;
volatile void *localAddress;
/*
* Make sure that devLib has been intialized
*/
if (!devLibInitFlag) {
status = devLibInit();
if(status){
return status;
}
}
/*
* Make sure we have a valid bus address
*/
status = addrVerify (addrType, busAddr, 4);
if (status) {
return status;
}
/*
* Call the virtual os routine to map the bus address to a CPU address
*/
status = (*pdevLibVME->pDevMapAddr) (addrType, 0, busAddr, 4, &localAddress);
if (status) {
errPrintf (status, __FILE__, __LINE__, "%s bus address =0X%X\n",
epicsAddressTypeName[addrType], (unsigned int)busAddr);
return status;
}
/*
* Return the local CPU address if the pointer is supplied
*/
if (ppLocalAddress) {
*ppLocalAddress = localAddress;
}
return SUCCESS;
}/*end devBusToLocalAddr()*/
/*
*
* initHandlerAddrList()
* init list of interrupt handlers to ignore
*
*/
static
void initHandlerAddrList(void)
{
int i;
for (i=0; i<NELEMENTS(defaultHandlerNames); i++) {
defaultHandlerAddr[i] = epicsFindSymbol(defaultHandlerNames[i]);
if(!defaultHandlerAddr[i]) {
errPrintf(
S_dev_internal,
__FILE__,
__LINE__,
"initHandlerAddrList() %s not in sym table",
defaultHandlerNames[i]);
}
}
}
void recGblDbaddrError(long status, const struct dbAddr *paddr,
const char *pmessage)
{
dbCommon *precord = 0;
dbFldDes *pdbFldDes = 0;
if(paddr) {
pdbFldDes = paddr->pfldDes;
precord = paddr->precord;
}
errPrintf(status,0,0,
"PV: %s.%s "
"error detected in routine: %s\n",
(paddr ? precord->name : "Unknown"),
(pdbFldDes ? pdbFldDes->name : ""),
(pmessage ? pmessage : "Unknown"));
return;
}
/*
* Set the value of an environment variable
* Leaks memory, but the assumption is that this routine won't be
* called often enough for the leak to be a problem.
*/
epicsShareFunc void epicsShareAPI epicsEnvSet (const char *name, const char *value)
{
char *cp;
cp = mallocMustSucceed (strlen (name) + strlen (value) + 2, "epicsEnvSet");
strcpy (cp, name);
strcat (cp, "=");
strcat (cp, value);
if (putenv (cp) < 0) {
errPrintf(
-1L,
__FILE__,
__LINE__,
"Failed to set environment parameter \"%s\" to \"%s\": %s\n",
name,
value,
strerror (errno));
free (cp);
}
}
void recGblRecSupError(long status, const struct dbAddr *paddr,
const char *pmessage, const char *psupport_name)
{
dbCommon *precord = 0;
dbFldDes *pdbFldDes = 0;
dbRecordType *pdbRecordType = 0;
if(paddr) {
precord = paddr->precord;
pdbFldDes = paddr->pfldDes;
if(pdbFldDes) pdbRecordType = pdbFldDes->pdbRecordType;
}
errPrintf(status,0,0,
"Record Support Routine (%s) "
"Record Type %s "
"PV %s.%s "
" %s\n",
(psupport_name ? psupport_name : "Unknown"),
(pdbRecordType ? pdbRecordType->name : "Unknown"),
(paddr ? precord->name : "Unknown"),
(pdbFldDes ? pdbFldDes->name : ""),
(pmessage ? pmessage : ""));
return;
}
/*
* devUnregisterAddress()
*/
long devUnregisterAddress(
epicsAddressType addrType,
size_t baseAddress,
const char *pOwnerName)
{
rangeItem *pRange;
int s;
if (!devLibInitFlag) {
s = devLibInit();
if(s) {
return s;
}
}
s = addrVerify (addrType, baseAddress, 1);
if (s != SUCCESS) {
return s;
}
epicsMutexMustLock(addrListLock);
pRange = (rangeItem *) ellFirst(&addrAlloc[addrType]);
while (pRange) {
if (pRange->begin == baseAddress) {
break;
}
if (pRange->begin > baseAddress) {
pRange = NULL;
break;
}
pRange = (rangeItem *) ellNext(&pRange->node);
}
epicsMutexUnlock(addrListLock);
if (!pRange) {
return S_dev_addressNotFound;
}
if (strcmp(pOwnerName,pRange->pOwnerName)) {
s = S_dev_addressOverlap;
errPrintf (
s,
__FILE__,
__LINE__,
"unregister address for %s at 0X%X failed because %s owns it",
pOwnerName,
(unsigned int)baseAddress,
pRange->pOwnerName);
return s;
}
epicsMutexMustLock(addrListLock);
ellDelete (&addrAlloc[addrType], &pRange->node);
epicsMutexUnlock(addrListLock);
pRange->pOwnerName = "<released fragment>";
devInsertAddress (&addrFree[addrType], pRange);
s = devCombineAdjacentBlocks (&addrFree[addrType], pRange);
if(s){
errMessage (s, "devCombineAdjacentBlocks error");
return s;
}
return SUCCESS;
}
static long dbReadCOM(DBBASE **ppdbbase,const char *filename, FILE *fp,
const char *path,const char *substitutions)
{
long status;
inputFile *pinputFile = NULL;
char *penv;
char **macPairs;
if(*ppdbbase == 0) *ppdbbase = dbAllocBase();
pdbbase = *ppdbbase;
if(path && strlen(path)>0) {
dbPath(pdbbase,path);
} else {
penv = getenv("EPICS_DB_INCLUDE_PATH");
if(penv) {
dbPath(pdbbase,penv);
} else {
dbPath(pdbbase,".");
}
}
my_buffer = dbCalloc(MY_BUFFER_SIZE,sizeof(char));
freeListInitPvt(&freeListPvt,sizeof(tempListNode),100);
if(substitutions) {
if(macCreateHandle(&macHandle,NULL)) {
epicsPrintf("macCreateHandle error\n");
status = -1;
goto cleanup;
}
macParseDefns(macHandle,(char *)substitutions,&macPairs);
if(macPairs ==NULL) {
macDeleteHandle(macHandle);
macHandle = NULL;
} else {
macInstallMacros(macHandle,macPairs);
free((void *)macPairs);
mac_input_buffer = dbCalloc(MY_BUFFER_SIZE,sizeof(char));
}
}
pinputFile = dbCalloc(1,sizeof(inputFile));
if(filename) {
pinputFile->filename = macEnvExpand(filename);
}
if(!fp) {
FILE *fp1;
if(pinputFile->filename) pinputFile->path = dbOpenFile(pdbbase,pinputFile->filename,&fp1);
if(!pinputFile->filename || !fp1) {
errPrintf(0,__FILE__, __LINE__,
"dbRead opening file %s",pinputFile->filename);
free((void *)pinputFile->filename);
free((void *)pinputFile);
status = -1;
goto cleanup;
}
pinputFile->fp = fp1;
} else {
pinputFile->fp = fp;
}
pinputFile->line_num = 0;
pinputFileNow = pinputFile;
my_buffer[0] = '\0';
my_buffer_ptr = my_buffer;
ellAdd(&inputFileList,&pinputFile->node);
status = pvt_yy_parse();
dbFreePath(pdbbase);
if(!status) { /*add RTYP and VERS as an attribute */
DBENTRY dbEntry;
DBENTRY *pdbEntry = &dbEntry;
long localStatus;
dbInitEntry(pdbbase,pdbEntry);
localStatus = dbFirstRecordType(pdbEntry);
while(!localStatus) {
localStatus = dbPutRecordAttribute(pdbEntry,"RTYP",
dbGetRecordTypeName(pdbEntry));
if(!localStatus) {
localStatus = dbPutRecordAttribute(pdbEntry,"VERS",
"none specified");
}
if(localStatus) {
fprintf(stderr,"dbPutRecordAttribute status %ld\n",status);
} else {
localStatus = dbNextRecordType(pdbEntry);
}
}
dbFinishEntry(pdbEntry);
}
cleanup:
if(macHandle) macDeleteHandle(macHandle);
macHandle = NULL;
if(mac_input_buffer) free((void *)mac_input_buffer);
mac_input_buffer = NULL;
if(freeListPvt) freeListCleanup(freeListPvt);
freeListPvt = NULL;
if(my_buffer) free((void *)my_buffer);
my_buffer = NULL;
freeInputFileList();
return(status);
}
/*
* devInstallAddr()
*/
static long devInstallAddr (
rangeItem *pRange, /* item on the free list to be split */
const char *pOwnerName,
epicsAddressType addrType,
size_t base,
size_t size,
volatile void **ppPhysicalAddress)
{
volatile void *pPhysicalAddress;
rangeItem *pNewRange;
size_t reqEnd = base + (size-1);
long status;
/*
* does it start below the specified block
*/
if (base < pRange->begin) {
return S_dev_badArgument;
}
/*
* does it end above the specified block
*/
if (reqEnd > pRange->end) {
return S_dev_badArgument;
}
/*
* always map through the virtual os in case the memory
* management is set up there
*/
status = (*pdevLibVME->pDevMapAddr) (addrType, 0, base,
size, &pPhysicalAddress);
if (status) {
errPrintf (status, __FILE__, __LINE__, "%s base=0X%X size = 0X%X",
epicsAddressTypeName[addrType], (unsigned int)base, (unsigned int)size);
return status;
}
/*
* set the callers variable if the pointer is supplied
*/
if (ppPhysicalAddress) {
*ppPhysicalAddress = pPhysicalAddress;
}
/*
* does it start at the beginning of the block
*/
if (pRange->begin == base) {
if (pRange->end == reqEnd) {
epicsMutexMustLock(addrListLock);
ellDelete(&addrFree[addrType], &pRange->node);
epicsMutexUnlock(addrListLock);
free ((void *)pRange);
}
else {
pRange->begin = base + size;
}
}
/*
* does it end at the end of the block
*/
else if (pRange->end == reqEnd) {
pRange->end = base-1;
}
/*
* otherwise split the item on the free list
*/
else {
pNewRange = (rangeItem *) calloc (1, sizeof(*pRange));
if(!pNewRange){
return S_dev_noMemory;
}
pNewRange->begin = base + size;
pNewRange->end = pRange->end;
pNewRange->pOwnerName = "<fragmented block>";
pNewRange->pPhysical = NULL;
pRange->end = base - 1;
/*
* add the node after the old item on the free list
* (blocks end up ordered by address)
*/
epicsMutexMustLock(addrListLock);
ellInsert(&addrFree[addrType], &pRange->node, &pNewRange->node);
epicsMutexUnlock(addrListLock);
}
/*
* allocate a new address range entry and add it to
* the list
*/
pNewRange = (rangeItem *)calloc (1, sizeof(*pRange));
if (!pNewRange) {
return S_dev_noMemory;
}
pNewRange->begin = base;
pNewRange->end = reqEnd;
pNewRange->pOwnerName = pOwnerName;
pNewRange->pPhysical = pPhysicalAddress;
devInsertAddress (&addrAlloc[addrType], pNewRange);
return SUCCESS;
}
int main( int argc, char *argv[] )
{
int in, out, i, rcparm = 0, pcnt;
int Rflag = FALSE, nflag = FALSE;
int uflag = FALSE;
int dllflag = FALSE;
char *wext = NULL;
long tsize = 0;
char drive[_MAX_DRIVE], dir[_MAX_DIR], fname[_MAX_FNAME];
char ext[_MAX_EXT];
char rex[_MAX_PATH];
char exe[_MAX_PATH];
char dll[_MAX_PATH];
char res[_MAX_PATH];
char winext[_MAX_PATH];
char rc[256];
long totalsize;
const char **arglist;
char *path = NULL;
int currarg,len;
simple_header re;
long exelen;
char *desc = NULL;
/*
* get parms
*/
if( argc < 2 ) {
doUsage( NULL );
}
currarg=1;
while( currarg < argc ) {
#ifdef __UNIX__
if( argv[ currarg ][0] == '-' ) {
#else
if( argv[ currarg ][0] == '/' || argv[ currarg ][0] == '-' ) {
#endif
len = strlen( argv[ currarg ] );
for( i=1; i<len; i++ ) {
switch( argv[ currarg ][i] ) {
case '?': doUsage( NULL );
case 'D':
currarg++;
desc = argv[ currarg ];
break;
case 's':
currarg++;
wext = argv[ currarg ];
break;
case 'q':
quietFlag = TRUE;
break;
case 'u':
uflag = TRUE;
break;
case 'n':
nflag = TRUE;
break;
case 'd':
dllflag = TRUE;
break;
case 'R': case 'r':
Rflag=TRUE;
rcparm = currarg+1;
if( rcparm == argc ) {
doUsage("must specify resource compiler command line" );
}
break;
}
}
if( Rflag ) {
break;
}
} else {
if( path != NULL ) {
doUsage( "Only one executable may be specified" );
}
path = argv[ currarg ];
}
currarg++;
}
if( path == NULL ) {
doUsage( "No executable to bind" );
}
doBanner();
/*
* get files to use
*/
_splitpath( path, drive, dir, fname, ext );
_makepath( rex, drive, dir, fname, ".rex" );
if( dllflag ) {
_makepath( dll, drive, dir, fname, ".dll" );
}
_makepath( exe, drive, dir, fname, ".exe" );
_makepath( res, drive, dir, fname, "" );
/*
* do the unbind
*/
if( uflag ) {
if( ext[0] == 0 ) {
path = exe;
}
in = open( path, O_RDONLY | O_BINARY );
if( in < 0 ) {
doError( "Could not open %s", path );
}
out = open( rex, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, PMODE_RWX );
if( out < 0 ) {
doError( "Could not open %s", rex );
}
lseek( in, MAGIC_OFFSET, SEEK_SET );
read( in, &exelen, sizeof( unsigned_32 ) );
lseek( in, exelen, SEEK_SET );
read( in, &re, sizeof( re ) );
if( re.signature != ('M' & ('Q' << 8)) ) {
doError( "Not a bound Open Watcom 32-bit Windows application" );
}
lseek( in, exelen, SEEK_SET );
CopyFile( in, out, path, rex );
close( in );
close( out );
myPrintf( ".rex file %s created", rex );
exit( 0 );
}
if( wext == NULL ) {
if( dllflag ) {
FindExtender( "w386dll.ext", winext );
} else {
FindExtender( "win386.ext", winext );
}
} else {
strcpy( winext, wext );
}
if( dllflag ) {
myPrintf("Loading 32-bit Windows DLL Supervisor \"%s\"\n",winext );
} else {
myPrintf("Loading 32-bit Windows Supervisor \"%s\"\n",winext );
}
/*
* open files
*/
in = open( winext, O_RDONLY | O_BINARY );
if( in < 0 ) {
doError( "Could not open %s", winext );
}
out = open( exe, O_CREAT | O_TRUNC|O_WRONLY | O_BINARY, PMODE_RWX );
if( out < 0 ) {
doError( "Could not open %s", exe );
}
/*
* copy extender over
*/
CopyFile( in, out, winext, exe );
close( in );
close( out );
/*
* run the resource compiler
*/
if( !nflag ) {
myPrintf( "Invoking the resource compiler...\n" );
if( Rflag ) {
strcpy( rc, RC_STR );
arglist = myAlloc( sizeof(char *) *(argc-rcparm +3) );
pcnt = 1;
for( i=rcparm;i<argc;i++ ) {
arglist[pcnt++] = argv[i];
strcat( rc," " );
strcat( rc, argv[i] );
}
} else {
sprintf( rc, RC_STR " %s", res );
arglist = myAlloc( sizeof(char *) * 3 );
arglist[1] = res;
pcnt = 2;
}
arglist[0] = RC_STR;
arglist[pcnt] = NULL;
myPrintf( "%s\n",rc );
i = spawnvp( P_WAIT, RC_STR, arglist );
if( i == -1 ) {
remove( exe );
switch( errno ) {
case E2BIG:
doError( "Argument list too big. Resource compiler step failed." );
break;
case ENOENT:
doError( "Could not find " RC_STR ".exe." );
break;
case ENOMEM:
doError( "Not enough memory. Resource compiler step failed." );
break;
}
doError( "Unknown error %d, resource compiler step failed.", errno );
}
if( i != 0 ) {
remove( exe );
errPrintf( "Resource compiler failed, return code = %d\n", i );
exit( i );
}
}
/*
* copy the rex file onto the end
*/
in = open( rex, O_RDONLY | O_BINARY );
if( in < 0 ) {
doError( "Could not open %s", rex );
}
out = open( exe, O_RDWR | O_BINARY );
if( out < 0 ) {
doError( "Could not open %s", exe );
}
lseek( out, 0, SEEK_END );
tsize = tell( out );
totalsize = CopyFile( in, out, rex, exe );
close( in );
/*
* noodle the file: change name, and then
* write the file size into the old exe header (for
* use by the loader)
*/
lseek( out, MAGIC_OFFSET, SEEK_SET );
write( out, &tsize, sizeof( tsize ) );
len = strlen( fname );
memset( &fname[len],' ',8-len );
updateNHStuff( out, fname, desc );
close( out );
if( dllflag ) {
remove( dll );
rename( exe,dll );
myPrintf("Created \"%s\" (%ld + %ld = %ld bytes)\n", dll,
tsize,totalsize, tsize+totalsize );
} else {
myPrintf("Created \"%s\" (%ld + %ld = %ld bytes)\n", exe,
tsize,totalsize, tsize+totalsize );
}
return( 0 );
} /* main */
/***************************************************
* initialize all software and hardware
* scalerVS_init()
****************************************************/
STATIC long scalerVS_init(int after)
{
volatile char *localAddr;
unsigned long status;
char *baseAddr;
int card, card_type;
uint32 probeValue = 0;
Debug(2,"scalerVS_init(): entry, after = %d\n", after);
if (after || (vs_num_cards == 0)) return(0);
/* allocate scalerVS_state structures, array of pointers */
if (scalerVS_state == NULL) {
scalerVS_state = (struct scalerVS_state **)
calloc(1, vs_num_cards * sizeof(struct scalerVS_state *));
scalerVS_total_cards=0;
for (card=0; card<vs_num_cards; card++) {
scalerVS_state[card] = (struct scalerVS_state *)
calloc(1, sizeof(struct scalerVS_state));
}
}
/* Check out the hardware. */
for (card=0; card<vs_num_cards; card++) {
baseAddr = (char *)(vs_addrs + card*CARD_ADDRESS_SPACE);
/* Can we reserve the required block of VME address space? */
status = devRegisterAddress(__FILE__, atVMEA16, (size_t)baseAddr,
CARD_ADDRESS_SPACE, (volatile void **)&localAddr);
if (!RTN_SUCCESS(status)) {
errPrintf(status, __FILE__, __LINE__,
"Can't register 2048-byte block in VME A16 at address %p\n", baseAddr);
return (ERROR);
}
if (devReadProbe(4,(volatile void *)(localAddr+READ_XFER_REG_OFFSET),(void*)&probeValue)) {
printf("scalerVS_init: no VSxx card at %p\n",localAddr);
return(0);
}
/* Declare victory. */
Debug(2,"scalerVS_init: we own 2048 bytes in VME A16 starting at %p\n", localAddr);
scalerVS_state[card]->localAddr = localAddr;
scalerVS_total_cards++;
/* reset this card */
/* any write to this address causes reset */
writeReg16(localAddr,MASTER_RESET_OFFSET,0);
/* get this card's type and serial number */
scalerVS_state[card]->ident = readReg16(localAddr,ID_OFFSET);
Debug(3,"scalerVS_init: Serial # = %d\n", scalerVS_state[card]->ident & 0x3FF);
/* get this card's type */
card_type = scalerVS_state[card]->ident >> 10;
if ((card_type > 22) || (card_type < 16)) {
errPrintf(status, __FILE__, __LINE__, "unrecognized module\n");
scalerVS_state[card]->num_channels = 0;
scalerVS_state[card]->card_exists = 0;
/*
* Something's wrong with this card, but we still count it in scalerVS_total_cards.
* A bad card retains its address space; otherwise we can't talk to the next one.
*/
} else {
scalerVS_state[card]->num_channels = VS_module_types[card_type-16].num_channels;
scalerVS_state[card]->card_exists = 1;
}
Debug(3,"scalerVS_init: nchan = %d\n", scalerVS_state[card]->num_channels);
}
Debug(3,"scalerVS_init: Total cards = %d\n\n",scalerVS_total_cards);
#ifdef vxWorks
if (epicsAtExit(scalerVS_shutdown, 0) < 0)
epicsPrintf ("scalerVS_init: epicsAtExit() failed\n");
#endif
Debug(3,"%s", "scalerVS_init: scalers initialized\n");
return(0);
}
/***************************************************
* initialize all software and hardware
* scaler_init()
****************************************************/
STATIC long scaler_init(int after)
{
volatile char *localAddr;
unsigned long status;
void *baseAddr;
int card, i;
uint32 probeValue = 0;
Debug(2,"scaler_init(): entry, after = %d\n", after);
if (after || (vsc_num_cards == 0)) return(0);
/* allocate scaler_state structures, array of pointers */
if (scaler_state == NULL) {
scaler_state = (struct scaler_state **)
calloc(1, vsc_num_cards * sizeof(struct scaler_state *));
scaler_total_cards=0;
for (card=0; card<vsc_num_cards; card++) {
scaler_state[card] = (struct scaler_state *)
calloc(1, sizeof(struct scaler_state));
}
}
/* Check out the hardware. */
for (card=0; card<vsc_num_cards; card++) {
baseAddr = (void *)(vsc_addrs + card*CARD_ADDRESS_SPACE);
/* Can we reserve the required block of VME address space? */
status = devRegisterAddress(__FILE__, atVMEA32, (size_t)baseAddr,
CARD_ADDRESS_SPACE, (volatile void **)&localAddr);
if (!RTN_SUCCESS(status)) {
errPrintf(status, __FILE__, __LINE__,
"Can't register 0x%x-byte block at address %p\n", CARD_ADDRESS_SPACE, baseAddr);
return (ERROR);
}
if (devReadProbe(4,(volatile void *)(localAddr+DATA_0_OFFSET),(void*)&probeValue)) {
printf("no VSC card at %p\n",localAddr);
return(0);
}
/* Declare victory. */
Debug(2,"scaler_init: we own 256 bytes starting at %p\n",localAddr);
scaler_state[card]->localAddr = localAddr;
scaler_total_cards++;
/* reset this card */
writeReg16(localAddr,RESET_OFFSET,0);
/* get this card's identification */
scaler_state[card]->ident = readReg16(localAddr,REV_SERIAL_NO_OFFSET);
Debug(3,"scaler_init: Serial # = %d\n", scaler_state[card]->ident);
scaler_state[card]->card_exists = 1;
/* get this card's type (8 or 16 channels?) */
Debug(2,"scaler_init:Base Address=0x%8.8x\n",(int)baseAddr);
Debug(2,"scaler_init:Local Address=0x%8.8x\n",(int)localAddr);
scaler_state[card]->num_channels = readReg16(localAddr,MODULE_TYPE_OFFSET) & 0x18;
Debug(3,"scaler_init: nchan = %d\n", scaler_state[card]->num_channels);
if (scaler_state[card]->num_channels < 8) {
scaler_state[card]->card_exists = 0;
continue;
}
for (i=0; i<MAX_SCALER_CHANNELS; i++) {
scaler_state[card]->preset[i] = 0;
}
}
Debug(3,"scaler_init: Total cards = %d\n\n",scaler_total_cards);
#ifdef vxWorks
if (epicsAtExit(scaler_shutdown, 0) < 0)
epicsPrintf ("scaler_init: epicsAtExit() failed\n");
#endif
Debug(3, "%s", "scaler_init: scalers initialized\n");
return(0);
}