1313 lines
24 KiB
C
1313 lines
24 KiB
C
/* devLib.c - support for allocation of common device resources */
|
||
/* @(#)$Id$*/
|
||
|
||
/*
|
||
* Original Author: Marty Kraimer
|
||
* Author: Jeff Hill
|
||
* Date: 03-10-93
|
||
*
|
||
* Experimental Physics and Industrial Control System (EPICS)
|
||
*
|
||
* Copyright 1991, the Regents of the University of California,
|
||
* and the University of Chicago Board of Governors.
|
||
*
|
||
* This software was produced under U.S. Government contracts:
|
||
* (W-7405-ENG-36) at the Los Alamos National Laboratory,
|
||
* and (W-31-109-ENG-38) at Argonne National Laboratory.
|
||
*
|
||
* Initial development by:
|
||
* The Controls and Automation Group (AT-8)
|
||
* Ground Test Accelerator
|
||
* Accelerator Technology Division
|
||
* Los Alamos National Laboratory
|
||
*
|
||
* Co-developed with
|
||
* The Controls and Computing Group
|
||
* Accelerator Systems Division
|
||
* Advanced Photon Source
|
||
* Argonne National Laboratory
|
||
*
|
||
* Modification Log:
|
||
* -----------------
|
||
* .01 03-10-93 joh original
|
||
* .02 03-18-93 joh index address alloc array by fundamental type
|
||
* .03 03-23-93 joh changed input parameter to be a fund
|
||
* address type in favor of the argument
|
||
* that the BSP will be reconfigured
|
||
* to use an EPICS standard address
|
||
* mode
|
||
* .04 04-08-93 joh made unsolicitedHandlerEPICS() external
|
||
* .05 04-08-92 joh better diagnostic if we cant find
|
||
* a default interrupt handler
|
||
* .06 05-06-93 joh added new parameter to devDisconnectInterrupt().
|
||
* See comment below.
|
||
* .07 05-28-93 joh Added block probe routines
|
||
* .08 05-28-93 joh Added an argument to devRegisterAddress()
|
||
* .09 05-28-93 joh Added devAddressMap()
|
||
* .10 06-14-93 joh Added devAllocAddress()
|
||
*
|
||
* NOTES:
|
||
* .01 06-14-93 joh needs devAllocInterruptVector() routine
|
||
*/
|
||
|
||
static char *sccsID = "@(#) $Id$";
|
||
|
||
|
||
#include <vxWorks.h>
|
||
#include <types.h>
|
||
#include <iv.h>
|
||
#include <vme.h>
|
||
#include <lstLib.h>
|
||
#include <sysLib.h>
|
||
#include <sysSymTbl.h>
|
||
#include <memLib.h>
|
||
#include <intLib.h>
|
||
#include <logLib.h>
|
||
#include <string.h>
|
||
#include <stdioLib.h>
|
||
#include <stdlib.h>
|
||
|
||
#include <fast_lock.h>
|
||
#define devLibGlobal
|
||
#include <devLib.h>
|
||
|
||
|
||
LOCAL LIST addrAlloc[atLast];
|
||
LOCAL LIST addrFree[atLast];
|
||
|
||
LOCAL void *addrLast[atLast] = {
|
||
(void *) 0xffff,
|
||
(void *) 0xffffff,
|
||
(void *) 0xffffffff};
|
||
|
||
LOCAL long addrFail[atLast] = {
|
||
S_dev_badA16,
|
||
S_dev_badA24,
|
||
S_dev_badA32};
|
||
|
||
LOCAL FAST_LOCK addrListLock;
|
||
LOCAL char addrListInit;
|
||
|
||
typedef struct{
|
||
NODE node;
|
||
const char *pOwnerName;
|
||
void *pFirst;
|
||
void *pLast;
|
||
}rangeItem;
|
||
|
||
/*
|
||
* A list of the names of the unexpected interrupt handlers
|
||
* ( some of these are provided by wrs )
|
||
*/
|
||
LOCAL char *defaultHandlerNames[] = {
|
||
"_excStub",
|
||
"_excIntStub",
|
||
"_unsolicitedHandlerEPICS"};
|
||
LOCAL void *defaultHandlerAddr[NELEMENTS(defaultHandlerNames)];
|
||
|
||
/*
|
||
* These routines are not exported
|
||
*/
|
||
LOCAL void initHandlerAddrList(void);
|
||
LOCAL int vectorInUse(unsigned vectorNumber);
|
||
LOCAL long initAddrList(void);
|
||
LOCAL long addrVerify(epicsAddressType addrType, void *address);
|
||
LOCAL void (*isrFetch(unsigned vectorNumber))();
|
||
LOCAL long blockFind(
|
||
epicsAddressType addrType,
|
||
void *pBlockFirst,
|
||
void *pBlockLast,
|
||
/* size needed */
|
||
unsigned long size,
|
||
/* n ls bits zero in base addr */
|
||
unsigned alignment,
|
||
/* base address found */
|
||
void **ppBase);
|
||
LOCAL long report_conflict(
|
||
epicsAddressType addrType,
|
||
void *pFirst,
|
||
void *pLast,
|
||
const char *pOwnerName);
|
||
LOCAL long devInsertAddress(
|
||
LIST *pRangeList,
|
||
rangeItem *pNewRange);
|
||
LOCAL long devListAddressMap(
|
||
LIST *pRangeList);
|
||
LOCAL long devCombineAdjacentBlocks(
|
||
LIST *pRangeList,
|
||
rangeItem *pRange);
|
||
LOCAL long devInstallAddr(
|
||
rangeItem *pRange,
|
||
const char *pOwnerName,
|
||
epicsAddressType addrType,
|
||
void *pFirst,
|
||
void *pLast,
|
||
void **pLocalAddress);
|
||
LOCAL long blockDivide(
|
||
epicsAddressType addrType,
|
||
void *pBlockFirst,
|
||
void *pBlockLast,
|
||
/* base address found */
|
||
void **ppBase,
|
||
unsigned long requestSize
|
||
);
|
||
LOCAL long blockProbe(
|
||
epicsAddressType addrType,
|
||
void *pFirst,
|
||
void *pLast
|
||
);
|
||
long locationProbe(
|
||
epicsAddressType addrType,
|
||
void *pLocation
|
||
);
|
||
|
||
/*
|
||
* this routine needs to be in the symbol table
|
||
* for this code to work correctly
|
||
*/
|
||
void unsolicitedHandlerEPICS(int vectorNumber);
|
||
/*
|
||
* this is in veclist.c
|
||
*/
|
||
int cISRTest(void (*)(), void (**)(), void **);
|
||
|
||
#define SUCCESS 0
|
||
|
||
|
||
|
||
/*
|
||
*
|
||
* devConnectInterrupt
|
||
*
|
||
* coded to support other interrupting types in the future
|
||
*
|
||
* wrapper to minimize driver dependency on vxWorks
|
||
*/
|
||
long devConnectInterrupt(
|
||
epicsInterruptType intType,
|
||
unsigned vectorNumber,
|
||
void (*pFunction)(),
|
||
void *parameter)
|
||
{
|
||
int status;
|
||
|
||
switch(intType){
|
||
case intCPU:
|
||
case intVME:
|
||
case intVXI:
|
||
if(vectorInUse(vectorNumber)){
|
||
return S_dev_vectorInUse;
|
||
}
|
||
status = intConnect(
|
||
(void *)INUM_TO_IVEC(vectorNumber),
|
||
pFunction,
|
||
(int) parameter);
|
||
if(status<0){
|
||
return S_dev_vxWorksVecInstlFail;
|
||
}
|
||
break;
|
||
default:
|
||
return S_dev_uknIntType;
|
||
}
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
|
||
/*
|
||
*
|
||
* devDisconnectInterrupt()
|
||
*
|
||
* wrapper to minimize driver dependency on vxWorks
|
||
*
|
||
* The parameter pFunction should be set to the C function pointer that
|
||
* was connected. It is used as a key to prevent a driver from removing
|
||
* an interrupt handler that was installed by another driver
|
||
*
|
||
*/
|
||
long devDisconnectInterrupt(
|
||
epicsInterruptType intType,
|
||
unsigned vectorNumber,
|
||
void (*pFunction)()
|
||
)
|
||
{
|
||
void (*psub)();
|
||
int status;
|
||
|
||
/*
|
||
* If pFunction not connected to this vector
|
||
* then they are probably disconnecting from the wrong vector
|
||
*/
|
||
psub = isrFetch(vectorNumber);
|
||
if(psub != pFunction){
|
||
return S_dev_vectorNotInUse;
|
||
}
|
||
|
||
switch(intType){
|
||
case intCPU:
|
||
case intVME:
|
||
case intVXI:
|
||
status = intConnect(
|
||
(void *)INUM_TO_IVEC(vectorNumber),
|
||
unsolicitedHandlerEPICS,
|
||
(int) vectorNumber);
|
||
if(status<0){
|
||
return S_dev_vxWorksVecInstlFail;
|
||
}
|
||
break;
|
||
default:
|
||
return S_dev_uknIntType;
|
||
}
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
|
||
/*
|
||
*
|
||
* devEnableInterruptLevel()
|
||
*
|
||
* wrapper to minimize driver dependency on vxWorks
|
||
*
|
||
*/
|
||
long devEnableInterruptLevel(
|
||
epicsInterruptType intType,
|
||
unsigned level)
|
||
{
|
||
int s;
|
||
|
||
switch(intType){
|
||
case intCPU:
|
||
case intVME:
|
||
case intVXI:
|
||
s = sysIntEnable(level);
|
||
if(s<0){
|
||
return S_dev_vxWorksIntEnFail;
|
||
}
|
||
break;
|
||
default:
|
||
return S_dev_uknIntType;
|
||
}
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
|
||
/*
|
||
*
|
||
* devDisableInterruptLevel()
|
||
*
|
||
* wrapper to minimize driver dependency on vxWorks
|
||
*
|
||
*/
|
||
long devDisableInterruptLevel(
|
||
epicsInterruptType intType,
|
||
unsigned level)
|
||
{
|
||
int s;
|
||
|
||
switch(intType){
|
||
case intCPU:
|
||
case intVME:
|
||
case intVXI:
|
||
s = sysIntDisable(level);
|
||
if(s<0){
|
||
return S_dev_vxWorksIntDissFail;
|
||
}
|
||
break;
|
||
default:
|
||
return S_dev_uknIntType;
|
||
}
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
|
||
/*
|
||
*
|
||
* devRegisterAddress()
|
||
*
|
||
*
|
||
*/
|
||
long devRegisterAddress(
|
||
const char *pOwnerName,
|
||
epicsAddressType addrType,
|
||
void *baseAddress,
|
||
unsigned long size,
|
||
void **pLocalAddress)
|
||
{
|
||
void *pFirst;
|
||
void *pLast;
|
||
rangeItem *pRange;
|
||
long s;
|
||
|
||
if(!addrListInit){
|
||
s = initAddrList();
|
||
if(s){
|
||
return s;
|
||
}
|
||
}
|
||
|
||
s = addrVerify(addrType, (void *) size);
|
||
if(s){
|
||
return s;
|
||
}
|
||
|
||
if(size == 0){
|
||
return S_dev_lowValue;
|
||
}
|
||
|
||
pFirst = baseAddress;
|
||
pLast = pFirst + size - 1;
|
||
|
||
FASTLOCK(&addrListLock);
|
||
pRange = (rangeItem *) addrFree[addrType].node.next;
|
||
while(pRange){
|
||
|
||
if(pRange->pFirst > pLast){
|
||
pRange = NULL;
|
||
break;
|
||
}
|
||
|
||
if(pRange->pFirst <= pFirst && pRange->pLast >= pLast){
|
||
break;
|
||
}
|
||
|
||
pRange = (rangeItem *) pRange->node.next;
|
||
}
|
||
FASTUNLOCK(&addrListLock);
|
||
|
||
if(!pRange){
|
||
s = report_conflict(addrType, pFirst, pLast, pOwnerName);
|
||
if(s){
|
||
return s;
|
||
}
|
||
else{
|
||
return S_dev_internal;
|
||
}
|
||
}
|
||
|
||
s = devInstallAddr(
|
||
pRange,
|
||
pOwnerName,
|
||
addrType,
|
||
pFirst,
|
||
pLast,
|
||
pLocalAddress);
|
||
return s;
|
||
}
|
||
|
||
|
||
/*
|
||
*
|
||
* devInstallAddr()
|
||
*
|
||
*/
|
||
LOCAL long devInstallAddr(
|
||
rangeItem *pRange, /* item on the free list to be split */
|
||
const char *pOwnerName,
|
||
epicsAddressType addrType,
|
||
void *pFirst,
|
||
void *pLast,
|
||
void **pLocalAddress)
|
||
{
|
||
rangeItem *pNewRange;
|
||
int s;
|
||
|
||
if(pLocalAddress){
|
||
int s1;
|
||
int s2;
|
||
|
||
s1 = sysBusToLocalAdrs(
|
||
EPICStovxWorksAddrType[addrType],
|
||
pLast,
|
||
(char **)pLocalAddress);
|
||
s2 = sysBusToLocalAdrs(
|
||
EPICStovxWorksAddrType[addrType],
|
||
pFirst,
|
||
(char **)pLocalAddress);
|
||
if(s1 || s2){
|
||
errPrintf(
|
||
S_dev_vxWorksAddrMapFail,
|
||
__FILE__,
|
||
__LINE__,
|
||
"%s base=0X %X size = 0X %X",
|
||
epicsAddressTypeName[addrType],
|
||
pFirst,
|
||
pLast-pFirst+1);
|
||
return S_dev_vxWorksAddrMapFail;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* split the item on the free list
|
||
* (when required)
|
||
*/
|
||
if(pRange->pFirst == pFirst && pRange->pLast == pLast){
|
||
FASTLOCK(&addrListLock);
|
||
lstDelete(&addrFree[addrType], &pRange->node);
|
||
FASTUNLOCK(&addrListLock);
|
||
free((void *)pRange);
|
||
}
|
||
else if(pRange->pFirst == pFirst){
|
||
pRange->pFirst = pLast+1;
|
||
}
|
||
else if(pRange->pLast == pLast){
|
||
pRange->pLast = pFirst-1;
|
||
}
|
||
else{
|
||
|
||
pNewRange = (rangeItem *) malloc(sizeof(*pRange));
|
||
if(!pNewRange){
|
||
return S_dev_noMemory;
|
||
}
|
||
pNewRange->pFirst = pLast+1;
|
||
pNewRange->pLast = pRange->pLast;
|
||
pNewRange->pOwnerName = "<fragmented block>";
|
||
pRange->pLast = pFirst-1;
|
||
/*
|
||
* add the node after the old item on the free list
|
||
* (blocks end up ordered by address)
|
||
*/
|
||
FASTLOCK(&addrListLock);
|
||
lstInsert(&addrFree[addrType], &pRange->node, &pNewRange->node);
|
||
FASTUNLOCK(&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->pFirst = pFirst;
|
||
pNewRange->pLast = pLast;
|
||
pNewRange->pOwnerName = pOwnerName;
|
||
|
||
s = devInsertAddress(&addrAlloc[addrType], pNewRange);
|
||
if(s){
|
||
free((void *)pNewRange);
|
||
return s;
|
||
}
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
|
||
/*
|
||
*
|
||
* report_conflict()
|
||
*
|
||
*
|
||
*/
|
||
LOCAL long report_conflict(
|
||
epicsAddressType addrType,
|
||
void *pFirst,
|
||
void *pLast,
|
||
const char *pOwnerName
|
||
)
|
||
{
|
||
rangeItem *pRange;
|
||
|
||
pRange = (rangeItem *) addrAlloc[addrType].node.next;
|
||
while(pRange){
|
||
|
||
if(pRange->pFirst <= pFirst && pRange->pLast >= pFirst){
|
||
break;
|
||
}
|
||
if(pRange->pFirst <= pLast && pRange->pLast >= pLast){
|
||
break;
|
||
}
|
||
if(pRange->pFirst > pLast){
|
||
pRange = NULL;
|
||
break;
|
||
}
|
||
|
||
pRange = (rangeItem *) pRange->node.next;
|
||
}
|
||
|
||
if(pRange){
|
||
errPrintf(
|
||
S_dev_addressOverlap,
|
||
__FILE__,
|
||
__LINE__,
|
||
"%10s 0X %08X - %08X Requested by %s",
|
||
epicsAddressTypeName[addrType],
|
||
pFirst,
|
||
pLast,
|
||
pOwnerName);
|
||
|
||
errPrintf(
|
||
S_dev_identifyOverlap,
|
||
__FILE__,
|
||
__LINE__,
|
||
"%10s 0X %08X - %08X Owned by %s",
|
||
epicsAddressTypeName[addrType],
|
||
pRange->pFirst,
|
||
pRange->pLast,
|
||
pRange->pOwnerName);
|
||
|
||
return S_dev_addressOverlap;
|
||
}
|
||
|
||
return S_dev_internal;
|
||
}
|
||
|
||
|
||
/*
|
||
*
|
||
* devUnregisterAddress()
|
||
*
|
||
*/
|
||
long devUnregisterAddress(
|
||
epicsAddressType addrType,
|
||
void *baseAddress,
|
||
const char *pOwnerName)
|
||
{
|
||
rangeItem *pRange;
|
||
int s;
|
||
|
||
if(!addrListInit){
|
||
s = initAddrList();
|
||
if(s){
|
||
return s;
|
||
}
|
||
}
|
||
|
||
s = addrVerify(addrType, baseAddress);
|
||
if(s != SUCCESS){
|
||
return s;
|
||
}
|
||
|
||
FASTLOCK(&addrListLock);
|
||
pRange = (rangeItem *) addrAlloc[addrType].node.next;
|
||
while(pRange){
|
||
if(pRange->pFirst == baseAddress){
|
||
break;
|
||
}
|
||
if(pRange->pFirst > baseAddress){
|
||
pRange = NULL;
|
||
break;
|
||
}
|
||
pRange = (rangeItem *) pRange->node.next;
|
||
}
|
||
FASTUNLOCK(&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,
|
||
baseAddress,
|
||
pRange->pOwnerName);
|
||
return s;
|
||
}
|
||
|
||
FASTLOCK(&addrListLock);
|
||
lstDelete(
|
||
&addrAlloc[addrType],
|
||
&pRange->node);
|
||
FASTUNLOCK(&addrListLock);
|
||
|
||
pRange->pOwnerName = "<released fragment>";
|
||
s = devInsertAddress(&addrFree[addrType], pRange);
|
||
if(s){
|
||
free((void *)pRange);
|
||
errMessage(s, "Allocated Device Address Leak");
|
||
return s;
|
||
}
|
||
s = devCombineAdjacentBlocks(&addrFree[addrType], pRange);
|
||
if(s){
|
||
errMessage(s, NULL);
|
||
return s;
|
||
}
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
|
||
/*
|
||
*
|
||
* devCombineAdjacentBlocks()
|
||
*
|
||
*
|
||
*/
|
||
LOCAL long devCombineAdjacentBlocks(
|
||
LIST *pRangeList,
|
||
rangeItem *pRange)
|
||
{
|
||
rangeItem *pBefore;
|
||
rangeItem *pAfter;
|
||
|
||
pBefore = (rangeItem *) pRange->node.previous;
|
||
pAfter = (rangeItem *) pRange->node.next;
|
||
|
||
/*
|
||
* combine adjacent blocks
|
||
*/
|
||
if(pBefore){
|
||
if(pBefore->pLast == pRange->pFirst-1){
|
||
FASTLOCK(&addrListLock);
|
||
pRange->pFirst = pBefore->pFirst;
|
||
lstDelete(pRangeList, &pBefore->node);
|
||
FASTUNLOCK(&addrListLock);
|
||
free((void *)pBefore);
|
||
}
|
||
}
|
||
|
||
if(pAfter){
|
||
if(pAfter->pFirst-1 == pRange->pLast){
|
||
FASTLOCK(&addrListLock);
|
||
pRange->pLast = pAfter->pLast;
|
||
lstDelete(pRangeList, &pAfter->node);
|
||
FASTUNLOCK(&addrListLock);
|
||
free((void *)pAfter);
|
||
}
|
||
}
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
|
||
/*
|
||
*
|
||
* devInsertAddress()
|
||
*
|
||
*
|
||
*/
|
||
LOCAL long devInsertAddress(
|
||
LIST *pRangeList,
|
||
rangeItem *pNewRange)
|
||
{
|
||
rangeItem *pBefore;
|
||
rangeItem *pAfter;
|
||
|
||
FASTLOCK(&addrListLock);
|
||
pAfter = (rangeItem *) pRangeList->node.next;
|
||
while(pAfter){
|
||
if(pNewRange->pLast < pAfter->pFirst){
|
||
break;
|
||
}
|
||
pAfter = (rangeItem *) pAfter->node.next;
|
||
}
|
||
|
||
if(pAfter){
|
||
pBefore = (rangeItem *) pAfter->node.previous;
|
||
lstInsert(pRangeList, &pBefore->node, &pNewRange->node);
|
||
}
|
||
else{
|
||
lstAdd(pRangeList, &pNewRange->node);
|
||
}
|
||
FASTUNLOCK(&addrListLock);
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
*
|
||
* devAllocAddress()
|
||
*
|
||
*
|
||
*/
|
||
long devAllocAddress(
|
||
const char *pOwnerName,
|
||
epicsAddressType addrType,
|
||
unsigned long size,
|
||
unsigned alignment, /* n ls bits zero in base addr*/
|
||
void **pLocalAddress)
|
||
{
|
||
int s;
|
||
rangeItem *pRange;
|
||
void *pBase;
|
||
|
||
s = addrVerify(addrType, (void *)size);
|
||
if(s){
|
||
return s;
|
||
}
|
||
|
||
if(size == 0){
|
||
return S_dev_lowValue;
|
||
}
|
||
|
||
FASTLOCK(&addrListLock);
|
||
pRange = (rangeItem *) addrFree[addrType].node.next;
|
||
while(pRange){
|
||
if(pRange->pLast-pRange->pFirst>=size-1){
|
||
void *pF;
|
||
void *pL;
|
||
|
||
s = blockFind(
|
||
addrType,
|
||
pRange->pFirst,
|
||
pRange->pLast,
|
||
size,
|
||
alignment,
|
||
&pBase);
|
||
if(!s){
|
||
break;
|
||
}
|
||
}
|
||
pRange = (rangeItem *) pRange->node.next;
|
||
}
|
||
FASTUNLOCK(&addrListLock);
|
||
|
||
if(!pRange){
|
||
s = S_dev_deviceDoesNotFit;
|
||
errMessage(s, epicsAddressTypeName[addrType]);
|
||
return s;
|
||
}
|
||
|
||
|
||
s = devInstallAddr(
|
||
pRange,
|
||
pOwnerName,
|
||
addrType,
|
||
pBase,
|
||
pBase + size - 1,
|
||
pLocalAddress);
|
||
return s;
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* addrVerify()
|
||
*/
|
||
LOCAL long addrVerify(
|
||
epicsAddressType addrType,
|
||
void *address)
|
||
{
|
||
if(addrType>=atLast){
|
||
return S_dev_uknAddrType;
|
||
}
|
||
|
||
if(address > addrLast[addrType]){
|
||
return addrFail[addrType];
|
||
}
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* initAddrList()
|
||
*/
|
||
LOCAL long initAddrList(void)
|
||
{
|
||
rangeItem *pRange;
|
||
|
||
if(NELEMENTS(addrAlloc) != NELEMENTS(addrFree)){
|
||
return S_dev_internal;
|
||
}
|
||
|
||
if(!addrListInit){
|
||
int i;
|
||
|
||
FASTLOCKINIT(&addrListLock);
|
||
|
||
FASTLOCK(&addrListLock);
|
||
for(i=0; i<NELEMENTS(addrAlloc); i++){
|
||
lstInit(&addrAlloc[i]);
|
||
lstInit(&addrFree[i]);
|
||
}
|
||
|
||
addrListInit = TRUE;
|
||
|
||
for(i=0; i<NELEMENTS(addrAlloc); i++){
|
||
pRange = (rangeItem *)malloc(sizeof *pRange);
|
||
if(!pRange){
|
||
return S_dev_noMemory;
|
||
}
|
||
pRange->pOwnerName = "<Vacant>";
|
||
pRange->pFirst = 0;
|
||
pRange->pLast = addrLast[i];
|
||
lstAdd(&addrFree[i], &pRange->node);
|
||
}
|
||
FASTUNLOCK(&addrListLock);
|
||
}
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
|
||
/*
|
||
* devAddressMap()
|
||
*/
|
||
long devAddressMap(void)
|
||
{
|
||
return devListAddressMap(addrAlloc);
|
||
}
|
||
|
||
|
||
/*
|
||
* devListAddressMap()
|
||
*/
|
||
LOCAL long devListAddressMap(LIST *pRangeList)
|
||
{
|
||
rangeItem *pri;
|
||
int i;
|
||
long s;
|
||
|
||
if(!addrListInit){
|
||
s = initAddrList();
|
||
if(s){
|
||
return s;
|
||
}
|
||
}
|
||
|
||
FASTLOCK(&addrListLock);
|
||
for(i=0; i<NELEMENTS(addrAlloc); i++){
|
||
pri = (rangeItem *) lstFirst(&pRangeList[i]);
|
||
if(pri){
|
||
printf("%s Address Map\n", epicsAddressTypeName[i]);
|
||
}
|
||
while(pri){
|
||
printf("0X %08X - %08X %s\n",
|
||
pri->pFirst,
|
||
pri->pLast,
|
||
pri->pOwnerName);
|
||
pri = (rangeItem *) lstNext(&pri->node);
|
||
}
|
||
}
|
||
FASTUNLOCK(&addrListLock);
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
|
||
/*
|
||
*
|
||
* unsolicitedHandlerEPICS()
|
||
* what gets called if they disconnect from an
|
||
* interrupt and an interrupt arrives on the
|
||
* disconnected vector
|
||
*
|
||
*/
|
||
void unsolicitedHandlerEPICS(int vectorNumber)
|
||
{
|
||
/*
|
||
* call logMsg() and not errMessage()
|
||
* so we are certain that printf()
|
||
* does not get called at interrupt level
|
||
*/
|
||
logMsg(
|
||
"%s: line=%d: Interrupt to EPICS disconnected vector = 0X %X",
|
||
(int)__FILE__,
|
||
__LINE__,
|
||
vectorNumber,
|
||
NULL,
|
||
NULL,
|
||
NULL);
|
||
}
|
||
|
||
|
||
/*
|
||
*
|
||
* initHandlerAddrList()
|
||
* init list of interrupt handlers to ignore
|
||
*
|
||
*/
|
||
LOCAL
|
||
void initHandlerAddrList(void)
|
||
{
|
||
int i;
|
||
UINT8 type;
|
||
int status;
|
||
|
||
for(i=0; i<NELEMENTS(defaultHandlerNames); i++){
|
||
status =
|
||
symFindByName( sysSymTbl,
|
||
defaultHandlerNames[i],
|
||
(char **)&defaultHandlerAddr[i],
|
||
&type);
|
||
if(status != OK){
|
||
errPrintf(
|
||
S_dev_internal,
|
||
__FILE__,
|
||
__LINE__,
|
||
"initHandlerAddrList() %s not in sym table",
|
||
defaultHandlerNames[i]);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
*
|
||
* isrFetch()
|
||
*
|
||
*
|
||
*/
|
||
LOCAL
|
||
void (*isrFetch(unsigned vectorNumber))()
|
||
{
|
||
void (*psub)();
|
||
void (*pCISR)();
|
||
void *pParam;
|
||
int s;
|
||
|
||
/*
|
||
* fetch the handler or C stub attached at this vector
|
||
*/
|
||
psub = (void (*)()) intVecGet((FUNCPTR *)INUM_TO_IVEC(vectorNumber));
|
||
|
||
/*
|
||
* from libvxWorks/veclist.c
|
||
*
|
||
* checks to see if it is a C ISR
|
||
* and if so finds the function pointer and
|
||
* the parameter passed
|
||
*/
|
||
s = cISRTest(psub, &pCISR, &pParam);
|
||
if(!s){
|
||
psub = pCISR;
|
||
}
|
||
|
||
return psub;
|
||
}
|
||
|
||
|
||
/*
|
||
*
|
||
* vectorInUse()
|
||
*
|
||
*
|
||
*/
|
||
LOCAL int
|
||
vectorInUse(
|
||
unsigned vectorNumber
|
||
)
|
||
{
|
||
static int init;
|
||
int i;
|
||
void (*psub)();
|
||
|
||
if(!init){
|
||
initHandlerAddrList();
|
||
init = TRUE;
|
||
}
|
||
|
||
psub = isrFetch(vectorNumber);
|
||
|
||
/*
|
||
* its a C routine. Does it match a default handler?
|
||
*/
|
||
for(i=0; i<NELEMENTS(defaultHandlerAddr); i++){
|
||
if(defaultHandlerAddr[i] == psub){
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
|
||
/*
|
||
*
|
||
* blockFind()
|
||
*
|
||
* Find unoccupied block in a large block
|
||
*
|
||
*/
|
||
LOCAL long blockFind(
|
||
epicsAddressType addrType,
|
||
void *pBlockFirst,
|
||
void *pBlockLast,
|
||
unsigned long size, /* size needed */
|
||
unsigned alignment, /* n ls bits zero in base addr */
|
||
void **ppBase /* base address found */
|
||
)
|
||
{
|
||
int s;
|
||
unsigned long mask;
|
||
|
||
/*
|
||
* align the block base
|
||
*/
|
||
mask = devCreateMask(alignment);
|
||
if(mask&(long)pBlockFirst){
|
||
pBlockFirst = (void *) (mask | (unsigned long) pBlockFirst);
|
||
pBlockFirst++;
|
||
}
|
||
|
||
if(pBlockFirst == 0){
|
||
return S_dev_badRequest;
|
||
}
|
||
|
||
if(pBlockLast < pBlockFirst){
|
||
return S_dev_badRequest;
|
||
}
|
||
|
||
/*
|
||
* align size of block
|
||
*/
|
||
if(mask & size){
|
||
size |= mask;
|
||
size++;
|
||
}
|
||
|
||
if(size == 0){
|
||
return S_dev_badRequest;
|
||
}
|
||
|
||
if(pBlockLast-pBlockFirst < size-1){
|
||
return S_dev_badRequest;
|
||
}
|
||
|
||
s = blockDivide(
|
||
addrType,
|
||
pBlockFirst,
|
||
pBlockFirst + (size-1),
|
||
ppBase,
|
||
size);
|
||
|
||
return s;
|
||
}
|
||
|
||
|
||
/*
|
||
* blockDivide()
|
||
* (binary search within a block)
|
||
* End up at a valid block without stepping through
|
||
* the entire address range.
|
||
*/
|
||
LOCAL long blockDivide(
|
||
epicsAddressType addrType,
|
||
void *pBlockFirst,
|
||
void *pBlockLast,
|
||
void **ppBase, /* base address found */
|
||
unsigned long requestSize
|
||
)
|
||
{
|
||
void *pBlock;
|
||
unsigned long bs;
|
||
int s;
|
||
|
||
s = blockProbe(addrType,pBlockFirst, pBlockFirst+(requestSize-1));
|
||
if(!s){
|
||
*ppBase = pBlockFirst;
|
||
return SUCCESS;
|
||
}
|
||
|
||
/*
|
||
* prevent unsigned long overflow
|
||
*/
|
||
bs = pBlockLast - pBlockFirst + 1;
|
||
if(bs == 0){
|
||
bs = 0x80000000;
|
||
}
|
||
else{
|
||
bs = bs >> 1;
|
||
}
|
||
|
||
while(bs > requestSize){
|
||
pBlock = pBlockFirst;
|
||
while(pBlock <= pBlockLast-bs+1){
|
||
pBlock += bs;
|
||
s = blockProbe(addrType, pBlock, pBlock+(requestSize-1));
|
||
if(!s){
|
||
*ppBase = pBlock;
|
||
return SUCCESS;
|
||
}
|
||
pBlock += bs;
|
||
}
|
||
bs = bs>>1;
|
||
}
|
||
return S_dev_deviceDoesNotFit;
|
||
}
|
||
|
||
|
||
/*
|
||
* blockProbe()
|
||
*/
|
||
LOCAL long blockProbe(
|
||
epicsAddressType addrType,
|
||
void *pFirst,
|
||
void *pLast
|
||
)
|
||
{
|
||
void *pProbe;
|
||
int s;
|
||
|
||
pProbe = pFirst;
|
||
while(pProbe <= pLast){
|
||
s = locationProbe(addrType, pProbe);
|
||
if(s){
|
||
return s;
|
||
}
|
||
pProbe++;
|
||
}
|
||
return SUCCESS;
|
||
}
|
||
|
||
|
||
/*
|
||
* locationProbe
|
||
*/
|
||
long locationProbe(
|
||
epicsAddressType addrType,
|
||
void *pLocation
|
||
)
|
||
{
|
||
void *pPhysical;
|
||
int s;
|
||
|
||
/*
|
||
* every byte in the block must
|
||
* map to a physical address
|
||
*/
|
||
s = sysBusToLocalAdrs(
|
||
EPICStovxWorksAddrType[addrType],
|
||
pLocation,
|
||
(char **)&pPhysical);
|
||
if(s<0){
|
||
return S_dev_vxWorksAddrMapFail;
|
||
}
|
||
|
||
|
||
{
|
||
char *pChar;
|
||
char byte;
|
||
|
||
pChar = pPhysical;
|
||
if(devPtrAlignTest(pChar)){
|
||
s = vxMemProbe(
|
||
pChar,
|
||
READ,
|
||
sizeof(byte),
|
||
&byte);
|
||
if(s!=ERROR){
|
||
return S_dev_addressOverlap;
|
||
}
|
||
}
|
||
}
|
||
{
|
||
short *pWord;
|
||
short word;
|
||
|
||
pWord = pPhysical;
|
||
if(devPtrAlignTest(pWord)){
|
||
s = vxMemProbe(
|
||
(char *)pWord,
|
||
READ,
|
||
sizeof(word),
|
||
(char *) &word);
|
||
if(s!=ERROR){
|
||
return S_dev_addressOverlap;
|
||
}
|
||
}
|
||
}
|
||
{
|
||
long *pLongWord;
|
||
long longWord;
|
||
|
||
pLongWord = pPhysical;
|
||
if(devPtrAlignTest(pLongWord)){
|
||
s = vxMemProbe(
|
||
(char *)pLongWord,
|
||
READ,
|
||
sizeof(longWord),
|
||
(char *)&longWord);
|
||
if(s!=ERROR){
|
||
return S_dev_addressOverlap;
|
||
}
|
||
}
|
||
}
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
/******************************************************************************
|
||
*
|
||
* The follwing may, or may not be present in the BSP for the CPU in use.
|
||
*
|
||
*/
|
||
void *sysA24Malloc(unsigned long size);
|
||
STATUS sysA24Free(void *pBlock);
|
||
|
||
/******************************************************************************
|
||
*
|
||
* Routines to use to allocate and free memory present in the A24 region.
|
||
*
|
||
******************************************************************************/
|
||
|
||
static void * (*A24MallocFunc)(size_t) = NULL;
|
||
static void (*A24FreeFunc)(void *) = NULL;
|
||
int devLibA24Debug = 0; /* Debugging flag */
|
||
|
||
void *devLibA24Calloc(size_t size)
|
||
{
|
||
void *ret;
|
||
|
||
ret = devLibA24Malloc(size);
|
||
|
||
if (ret == NULL)
|
||
return (NULL);
|
||
|
||
memset(ret, 0x00, size);
|
||
return(ret);
|
||
}
|
||
|
||
void *devLibA24Malloc(size_t size)
|
||
{
|
||
SYM_TYPE stype;
|
||
static int UsingBSP = 0;
|
||
void *ret;
|
||
|
||
if (devLibA24Debug)
|
||
logMsg("devLibA24Malloc(%d) entered\n", size, 0,0,0,0,0);
|
||
|
||
if (A24MallocFunc == NULL)
|
||
{
|
||
/* See if the sysA24Malloc() function is present. */
|
||
if(symFindByName(sysSymTbl,"_sysA24Malloc", (char**)&A24MallocFunc,&stype)==ERROR)
|
||
{ /* Could not find sysA24Malloc... use the malloc one and hope we are OK */
|
||
if (devLibA24Debug)
|
||
logMsg("devLibA24Malloc() using regular malloc\n",0,0,0,0,0,0);
|
||
A24MallocFunc = malloc;
|
||
A24FreeFunc = free;
|
||
}
|
||
else
|
||
{
|
||
if(symFindByName(sysSymTbl,"_sysA24Free", (char**)&A24FreeFunc, &stype) == ERROR)
|
||
{ /* That's strange... we have malloc, but no free! */
|
||
if (devLibA24Debug)
|
||
logMsg("devLibA24Malloc() using regular malloc\n",0,0,0,0,0,0);
|
||
A24MallocFunc = malloc;
|
||
A24FreeFunc = free;
|
||
}
|
||
else
|
||
UsingBSP = 1;
|
||
}
|
||
}
|
||
ret = A24MallocFunc(size);
|
||
|
||
if ((ret == NULL) && (UsingBSP))
|
||
errMessage(S_dev_noMemory, "devLibA24Malloc ran out of A24 memory, try sysA24MapRam(size)");
|
||
|
||
return(ret);
|
||
}
|
||
|
||
void devLibA24Free(void *pBlock)
|
||
{
|
||
if (devLibA24Debug)
|
||
logMsg("devLibA24Free(%p) entered\n", (unsigned long)pBlock,0,0,0,0,0);
|
||
|
||
A24FreeFunc(pBlock);
|
||
}
|