int ListApplyToEach (list_t list, int ascending,
ListApplicationFunc funcToApply,
void *callbackData)
{
int result = 0, index;
if (!list || !funcToApply)
goto Error;
if (ascending) {
for (index = 1; index <= ListNumItems (list); index++) {
result = funcToApply (index,
ListGetPtrToItem (list, index),
callbackData);
if (result < 0)
goto Error;
}
} else {
for (index = ListNumItems (list);
index > 0 && index <= ListNumItems (list);
index--) {
result = funcToApply (index,
ListGetPtrToItem (list, index),
callbackData);
if (result < 0)
goto Error;
}
}
Error:
return result;
}
/// HIFN Disconnects a Source VChan from all its Sink VChans
static BOOL disconnectSourceVChan (SourceVChan_type* srcVChan)
{
if (!srcVChan) return FALSE;
SinkVChan_type* sinkVChan = NULL;
for (size_t i = 1; i <= ListNumItems(srcVChan->sinkVChans); i++) {
sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, i);
sinkVChan->sourceVChan = NULL;
// if Sink VChan is open, close it
if (sinkVChan->baseClass.isOpen) {
sinkVChan->baseClass.isOpen = VChan_Closed;
if (sinkVChan->baseClass.VChanStateChangeCBFptr)
(*sinkVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)sinkVChan, sinkVChan->baseClass.VChanOwner, sinkVChan->baseClass.isOpen);
}
}
ListClear(srcVChan->sinkVChans);
// if Source VChan is open, close it
if (srcVChan->baseClass.isOpen) {
srcVChan->baseClass.isOpen = VChan_Closed;
if (srcVChan->baseClass.VChanStateChangeCBFptr)
(*srcVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)srcVChan, srcVChan->baseClass.VChanOwner, srcVChan->baseClass.isOpen);
}
return TRUE;
}
int console_assign (int file, char *devname)
{
int flag, i;
/* Check for valid file */
switch (file) {
case stdin:
flag = DEV_FLAGS_INPUT;
break;
case stdout:
case stderr:
flag = DEV_FLAGS_OUTPUT;
break;
default:
return -1;
}
/* Check for valid device name */
for (i = 1; i <= ListNumItems (devlist); i++) {
device_t *dev = ListGetPtrToItem (devlist, i);
if (strcmp (devname, dev->name) == 0) {
if (dev->flags & flag)
return console_setfile (file, dev);
return -1;
}
}
return -1;
}
int do_coninfo (cmd_tbl_t * cmd, int flag, int argc, char *argv[])
{
int i, l;
/* Scan for valid output and input devices */
puts ("List of available devices:\n");
for (i = 1; i <= ListNumItems (devlist); i++) {
device_t *dev = ListGetPtrToItem (devlist, i);
printf ("%-8s %08x %c%c%c ",
dev->name,
dev->flags,
(dev->flags & DEV_FLAGS_SYSTEM) ? 'S' : '.',
(dev->flags & DEV_FLAGS_INPUT) ? 'I' : '.',
(dev->flags & DEV_FLAGS_OUTPUT) ? 'O' : '.');
for (l = 0; l < MAX_FILES; l++) {
if (stdio_devices[l] == dev) {
printf ("%s ", stdio_names[l]);
}
}
putc ('\n');
}
return 0;
}
/// HIFN Given a Source VChan, the function returns the name of the Sink VChan attached to the source having the 1-based index sinkIdx. If index is out of range it returns NULL.
char* GetSinkVChanName (SourceVChan_type* srcVChan, size_t sinkIdx)
{
SinkVChan_type* sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, sinkIdx);
if (!sinkVChan) return NULL;
return GetVChanName((VChan_type*)sinkVChan);
}
int SendDataPacket (SourceVChan_type* srcVChan, DataPacket_type** dataPacketPtr, BOOL srcVChanNeedsPacket, char** errorMsg)
{
INIT_ERR
size_t nSinks = ListNumItems(srcVChan->sinkVChans);
SinkVChan_type* sinkVChan = NULL;
size_t nPacketsSent = 0; // counts to how many Sink VChans the packet has been sent successfuly
size_t nPacketRecipients = 0; // counts the number of packet recipients
// set packet counter
// Note: Since the Source VChan is open, an active Sink VChan is also an open Sink VChan
if (srcVChanNeedsPacket) {
nPacketRecipients = GetNumOpenSinkVChans(srcVChan)+1;
nPacketsSent++;
} else
nPacketRecipients = GetNumOpenSinkVChans(srcVChan);
if (*dataPacketPtr)
SetDataPacketCounter(*dataPacketPtr, nPacketRecipients);
// if there are no recipients then dispose of the data packet
if (!nPacketRecipients) {
ReleaseDataPacket(dataPacketPtr);
return 0;
}
// send data packet
for (size_t i = 1; i <= nSinks; i++) {
sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans,i);
if (!sinkVChan->baseClass.isOpen) continue; // forward packet only to open Sink VChans connected to this Source VChan
// put data packet into Sink VChan TSQ
CmtErrChk( CmtWriteTSQData(sinkVChan->tsqHndl, dataPacketPtr, 1, (int)sinkVChan->writeTimeout, NULL) );
nPacketsSent++;
}
*dataPacketPtr = NULL; // Data packet is considered to be consumed even if sending to some Sink VChans did not succeed
// Sink VChans that did receive the data packet, can further process it and release it.
return 0;
CmtError:
Cmt_ERR
Error:
// cleanup
for (size_t i = 0; i < nPacketRecipients - nPacketsSent; i++)
ReleaseDataPacket(dataPacketPtr);
RETURN_ERR
}
int device_deregister(char *devname)
{
int i,l,dev_index;
device_t *dev = NULL;
char temp_names[3][8];
dev_index=-1;
for (i=1; i<=ListNumItems(devlist); i++) {
dev = ListGetPtrToItem (devlist, i);
if(strcmp(dev->name,devname)==0) {
dev_index=i;
break;
}
}
if(dev_index<0) /* device not found */
return 0;
/* get stdio devices (ListRemoveItem changes the dev list) */
for (l=0 ; l< MAX_FILES; l++) {
if (stdio_devices[l] == dev) {
/* Device is assigned -> report error */
return -1;
}
memcpy (&temp_names[l][0],
stdio_devices[l]->name,
sizeof(stdio_devices[l]->name));
}
ListRemoveItem(devlist,NULL,dev_index);
/* reassign Device list */
for (i=1; i<=ListNumItems(devlist); i++) {
dev = ListGetPtrToItem (devlist, i);
for (l=0 ; l< MAX_FILES; l++) {
if(strcmp(dev->name,temp_names[l])==0) {
stdio_devices[l] = dev;
}
}
}
return 0;
}
void ListDisposePtrList (list_t list)
{
int index;
int numItems;
if (list) {
numItems = ListNumItems (list);
for (index = 1; index <= numItems; index++)
free (*(void **) ListGetPtrToItem (list, index));
ListDispose (list);
}
}
static size_t GetNumOpenSinkVChans (SourceVChan_type* srcVChan)
{
SinkVChan_type* sinkVChan = NULL;
size_t nSinkVChans = ListNumItems(srcVChan->sinkVChans);
size_t nOpenSinkVChans = 0;
for (size_t i = 1; i <= nSinkVChans; i++) {
sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, i);
if (sinkVChan->baseClass.isOpen)
nOpenSinkVChans++;
}
return nOpenSinkVChans;
}
/// HIFN Checks if a VChan object exists among a list of VChans of VChan_type*.
/// OUT idx 1-based index of the found VChan object within the VChan list.Pass 0 if this is not needed. If item is not found, *idx is 0.
/// HIRET TRUE if VChan exists, FALSE otherwise.
BOOL VChanExists (ListType VChanList, VChan_type* VChan, size_t* idx)
{
VChan_type* VChanItem = NULL;
size_t nVChans = ListNumItems(VChanList);
for (size_t i = 1; i <= nVChans; i++) {
VChanItem = *(VChan_type**)ListGetPtrToItem(VChanList, i);
if (VChanItem == VChan) {
if (idx) *idx = i;
return TRUE;
}
}
if (idx) *idx = 0;
return FALSE;
}
/// HIFN Searches for a given VChan name from a VChan list of VChan_type* and if found, returns a pointer to the VChan object.
/// OUT idx 1-based index of VChan object in the list of VChans. Pass 0 if this is not needed. If item is not found, *idx is 0.
/// HIRET Pointer to the found VChan_type* if VChan exists, NULL otherwise.
VChan_type* VChanNameExists (ListType VChanList, char VChanName[], size_t* idx)
{
VChan_type* VChan = NULL;
size_t nVChans = ListNumItems(VChanList);
for (size_t i = 1; i <= nVChans; i++) {
VChan = *(VChan_type**)ListGetPtrToItem(VChanList, i);
if (!strcmp(VChan->name, VChanName)) {
if (idx) *idx = i;
return VChan;
}
}
if (idx) *idx = 0;
return NULL;
}
/* search a device */
device_t *search_device (int flags, char *name)
{
int i, items;
device_t *dev = NULL;
items = ListNumItems (devlist);
if (name == NULL)
return dev;
for (i = 1; i <= items; i++) {
dev = ListGetPtrToItem (devlist, i);
if ((dev->flags & flags) && (strcmp (name, dev->name) == 0)) {
break;
}
}
return dev;
}
void DAQLabModule_empty (ListType* modules)
{
DAQLabModule_type** modPtrPtr;
size_t nummodules = ListNumItems(*modules);
if (!(*modules)) return;
for (size_t i = 1; i <= nummodules; i++) {
modPtrPtr = ListGetPtrToItem(*modules, i);
// call discard method specific to each module
(*(*modPtrPtr)->Discard)(modPtrPtr);
}
ListDispose(*modules);
*modules = 0;
}
/// HIFN Connects a Source VChan and Sink VChan. If the provided Sink VChan is connected to another Source VChan, it is first disconnected from that Source VChan.
/// HIFN If both Source and Sink VChans are active then they will be opened if they are closed.
/// HIRET True if successful, False otherwise.
BOOL VChan_Connect (SourceVChan_type* srcVChan, SinkVChan_type* sinkVChan)
{
if (!srcVChan || !sinkVChan) return FALSE;
SinkVChan_type* connectedSinkVChan = NULL;
size_t nSinks = ListNumItems(srcVChan->sinkVChans);
// check if the provided Sink VChan is already connected to this Source VChan
for (size_t i = 1; i <= nSinks; i++) {
connectedSinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, i);
if (connectedSinkVChan == sinkVChan) return FALSE;
}
// if Sink VChan is already connected to another Source VChan, disconnect it from that Source VChan
if (sinkVChan->sourceVChan)
if(!VChan_Disconnect((VChan_type*)sinkVChan) ) return FALSE; // error
// add sink to source's list of sinks
if (!ListInsertItem(srcVChan->sinkVChans, &sinkVChan, END_OF_LIST)) return FALSE; // error
// add Source VChan to Sink VChan
sinkVChan->sourceVChan = srcVChan;
// if both Sink and Source VChans are active, then open Sink VChan and also Source VChan if it is not open already
if (srcVChan->baseClass.isActive && sinkVChan->baseClass.isActive) {
// open Sink VChan
sinkVChan->baseClass.isOpen = VChan_Open;
if (sinkVChan->baseClass.VChanStateChangeCBFptr)
(*sinkVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)sinkVChan, sinkVChan->baseClass.VChanOwner, sinkVChan->baseClass.isOpen);
// open Source VChan if not open already
if (!srcVChan->baseClass.isOpen) {
srcVChan->baseClass.isOpen = VChan_Open;
if (srcVChan->baseClass.VChanStateChangeCBFptr)
(*srcVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)srcVChan, srcVChan->baseClass.VChanOwner, srcVChan->baseClass.isOpen);
}
}
return TRUE;
}
void SetSourceVChanDataType (SourceVChan_type* srcVChan, DLDataTypes dataType)
{
// disconnect Sink VChans if they are incompatible
size_t nSinks = ListNumItems(srcVChan->sinkVChans);
SinkVChan_type* sinkVChan;
BOOL compatibleVChans;
for (size_t i = 1; i <= nSinks; i++) {
sinkVChan = *(SinkVChan_type**) ListGetPtrToItem(srcVChan->sinkVChans, i);
compatibleVChans = FALSE;
for (size_t j = 0; j < sinkVChan->nDataTypes; j++)
if (srcVChan->dataType == sinkVChan->dataTypes[j]) {
compatibleVChans = TRUE;
break;
}
if (!compatibleVChans)
VChan_Disconnect((VChan_type*)sinkVChan);
}
// change Source VChan data type
srcVChan->dataType = dataType;
}
static BOOL disconnectSinkVChan (SinkVChan_type* sinkVChan)
{
if (!sinkVChan) return FALSE;
SinkVChan_type* connectedSinkVChan = NULL;
SourceVChan_type* srcVChan = sinkVChan->sourceVChan;
if (!srcVChan) return TRUE; // do nothing if there is no source to disconnect
// remove Source VChan from Sink VChan
sinkVChan->sourceVChan = NULL;
// if Sink VChan is open, close it
if (sinkVChan->baseClass.isOpen) {
sinkVChan->baseClass.isOpen = VChan_Closed;
if (sinkVChan->baseClass.VChanStateChangeCBFptr)
(*sinkVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)sinkVChan, sinkVChan->baseClass.VChanOwner, sinkVChan->baseClass.isOpen);
}
// remove Sink VChan from Source VChan
for (size_t i = 1; i <= ListNumItems(srcVChan->sinkVChans); i++) {
connectedSinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, i);
if (connectedSinkVChan == sinkVChan) {
ListRemoveItem(srcVChan->sinkVChans, 0, i);
// if Source VChan is open and there are no more active Sinks, then close Source VChan
if (srcVChan->baseClass.isOpen && !GetNumActiveSinkVChans(srcVChan)) {
srcVChan->baseClass.isOpen = VChan_Closed;
if (srcVChan->baseClass.VChanStateChangeCBFptr)
(*srcVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)srcVChan, srcVChan->baseClass.VChanOwner, srcVChan->baseClass.isOpen);
}
return TRUE;
}
}
return FALSE;
}
void ListRemoveDuplicates (list_t list, CompareFunction compareFunction)
{
int numItems, index, startIndexForFind, duplicatesIndex;
numItems = ListNumItems (list);
for (index = 1; index < numItems; index++) {
startIndexForFind = index + 1;
while (startIndexForFind <= numItems) {
duplicatesIndex =
ListFindItem (list,
ListGetPtrToItem (list, index),
startIndexForFind,
compareFunction);
if (duplicatesIndex > 0) {
ListRemoveItem (list, NULL, duplicatesIndex);
numItems--;
startIndexForFind = duplicatesIndex;
} else {
break;
}
}
}
}
int console_init_r (void)
{
device_t *inputdev = NULL, *outputdev = NULL;
int i, items = ListNumItems (devlist);
#ifdef CONFIG_SPLASH_SCREEN
if (getenv("splashimage") != NULL)
outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev");
#endif
#ifdef CONFIG_SILENT_CONSOLE
if (gd->flags & GD_FLG_SILENT)
outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev");
#endif
for (i = 1;
(i <= items) && ((inputdev == NULL) || (outputdev == NULL));
i++
) {
device_t *dev = ListGetPtrToItem (devlist, i);
if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
inputdev = dev;
}
if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
outputdev = dev;
}
}
if (outputdev != NULL) {
console_setfile (stdout, outputdev);
console_setfile (stderr, outputdev);
}
if (inputdev != NULL) {
console_setfile (stdin, inputdev);
}
gd->flags |= GD_FLG_DEVINIT;
#ifndef CFG_CONSOLE_INFO_QUIET
puts ("In: ");
if (stdio_devices[stdin] == NULL) {
puts ("No input devices available!\n");
} else {
printf ("%s\n", stdio_devices[stdin]->name);
}
puts ("Out: ");
if (stdio_devices[stdout] == NULL) {
puts ("No output devices available!\n");
} else {
printf ("%s\n", stdio_devices[stdout]->name);
}
puts ("Err: ");
if (stdio_devices[stderr] == NULL) {
puts ("No error devices available!\n");
} else {
printf ("%s\n", stdio_devices[stderr]->name);
}
#endif
for (i = 0; i < 3; i++) {
setenv (stdio_names[i], stdio_devices[i]->name);
}
#if 0
if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
return (0);
#endif
return (0);
}
void SetVChanActive (VChan_type* VChan, BOOL isActive)
{
// if it has the same active/inactive status, do nothing
if (VChan->isActive == isActive) return;
// update active/inactive
VChan->isActive = isActive;
// open/close VChans if neccessary
switch (VChan->dataFlow) {
case VChan_Source:
if (VChan->isActive) { // Inactive -> Active
// Source VChan is closed. Open Source VChan if it has at least an active Sink VChan
if (GetNumActiveSinkVChans((SourceVChan_type*)VChan)) {
VChan->isOpen = VChan_Open;
if (VChan->VChanStateChangeCBFptr)
(*VChan->VChanStateChangeCBFptr) (VChan, VChan->VChanOwner, VChan->isOpen);
}
// Sink VChans are closed. Open active Sink VChans.
SinkVChan_type* sinkVChan = NULL;
size_t nSinks = ListNumItems(((SourceVChan_type*)VChan)->sinkVChans);
for (size_t i = 1; i <= nSinks; i++) {
sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(((SourceVChan_type*)VChan)->sinkVChans, i);
if (!sinkVChan->baseClass.isActive) continue; // skip inactive Sink VChans
sinkVChan->baseClass.isOpen = VChan_Open;
if (sinkVChan->baseClass.VChanStateChangeCBFptr)
(*sinkVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)sinkVChan, sinkVChan->baseClass.VChanOwner, sinkVChan->baseClass.isOpen);
}
} else { // Active -> Inactive
// If Source VChan is open, then close it
if (VChan->isOpen) {
VChan->isOpen = VChan_Closed;
if (VChan->VChanStateChangeCBFptr)
(*VChan->VChanStateChangeCBFptr) (VChan, VChan->VChanOwner, VChan->isOpen);
}
// Close all open Sink VChans
SinkVChan_type* sinkVChan = NULL;
size_t nSinks = ListNumItems(((SourceVChan_type*)VChan)->sinkVChans);
for (size_t i = 1; i <= nSinks; i++) {
sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(((SourceVChan_type*)VChan)->sinkVChans, i);
if (!sinkVChan->baseClass.isOpen) continue; // skip closed Sink VChans
sinkVChan->baseClass.isOpen = VChan_Closed;
if (sinkVChan->baseClass.VChanStateChangeCBFptr)
(*sinkVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)sinkVChan, sinkVChan->baseClass.VChanOwner, sinkVChan->baseClass.isOpen);
}
}
break;
case VChan_Sink:
if (VChan->isActive) { // Inactive -> Active
// Sink VChan is closed, open Sink VChan if a Source VChan is attached to it and is active
SourceVChan_type* srcVChan = ((SinkVChan_type*)VChan)->sourceVChan;
if (srcVChan && srcVChan->baseClass.isActive) {
VChan->isOpen = VChan_Open;
if (VChan->VChanStateChangeCBFptr)
(*VChan->VChanStateChangeCBFptr) (VChan, VChan->VChanOwner, VChan->isOpen);
}
// If Sink VChan has a closed active Source VChan, then open the Source VChan
if (srcVChan && srcVChan->baseClass.isActive && !srcVChan->baseClass.isOpen) {
srcVChan->baseClass.isOpen = VChan_Open;
if (srcVChan->baseClass.VChanStateChangeCBFptr)
(*srcVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)srcVChan, srcVChan->baseClass.VChanOwner, srcVChan->baseClass.isOpen);
}
} else { // Active -> Inactive
// Close Sink VChan if open
if (VChan->isOpen) {
VChan->isOpen = VChan_Closed;
if (VChan->VChanStateChangeCBFptr)
(*VChan->VChanStateChangeCBFptr) (VChan, VChan->VChanOwner, VChan->isOpen);
}
// If Sink has an open Source VChan and there are no more active Sinks, then close Source VChan
SourceVChan_type* srcVChan = ((SinkVChan_type*)VChan)->sourceVChan;
if (srcVChan && srcVChan->baseClass.isOpen && !GetNumActiveSinkVChans(srcVChan)) {
srcVChan->baseClass.isOpen = VChan_Closed;
if (srcVChan->baseClass.VChanStateChangeCBFptr)
(*srcVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)srcVChan, srcVChan->baseClass.VChanOwner, srcVChan->baseClass.isOpen);
}
}
break;
}
}
/* Called after the relocation - use desired console functions */
int console_init_r (void)
{
device_t *inputdev = NULL, *outputdev = NULL;
int i, items = ListNumItems (devlist);
#ifdef CONFIG_SPLASH_SCREEN
/* suppress all output if splash screen is enabled and we have
a bmp to display */
if (getenv("splashimage") != NULL)
gd->flags |= GD_FLG_SILENT;
#endif
/* Scan devices looking for input and output devices */
for (i = 1;
(i <= items) && ((inputdev == NULL) || (outputdev == NULL));
i++
) {
device_t *dev = ListGetPtrToItem (devlist, i);
if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
inputdev = dev;
}
if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
outputdev = dev;
}
}
/* Initializes output console first */
if (outputdev != NULL) {
console_setfile (stdout, outputdev);
console_setfile (stderr, outputdev);
}
/* Initializes input console */
if (inputdev != NULL) {
console_setfile (stdin, inputdev);
}
gd->flags |= GD_FLG_DEVINIT; /* device initialization completed */
#ifndef CFG_CONSOLE_INFO_QUIET
/* Print information */
puts ("In: ");
if (stdio_devices[stdin] == NULL) {
puts ("No input devices available!\n");
} else {
printf ("%s\n", stdio_devices[stdin]->name);
}
puts ("Out: ");
if (stdio_devices[stdout] == NULL) {
puts ("No output devices available!\n");
} else {
printf ("%s\n", stdio_devices[stdout]->name);
}
puts ("Err: ");
if (stdio_devices[stderr] == NULL) {
puts ("No error devices available!\n");
} else {
printf ("%s\n", stdio_devices[stderr]->name);
}
#endif /* CFG_CONSOLE_INFO_QUIET */
/* Setting environment variables */
for (i = 0; i < 3; i++) {
setenv (stdio_names[i], stdio_devices[i]->name);
}
#if 0
/* If nothing usable installed, use only the initial console */
if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
return (0);
#endif
return (0);
}
SinkVChan_type* GetSinkVChan (SourceVChan_type* srcVChan, size_t sinkIdx)
{
SinkVChan_type* sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, sinkIdx);
return sinkVChan;
}
