interfaces.c

Go to the documentation of this file.

/*============================================================================*
 * FILE:                      interfaces.c
 *============================================================================*
 *
 *                      COPYRIGHT (C) 2006  BY
 *          CONDOR ENGINEERING, INC., SANTA BARBARA, CALIFORNIA
 *          ALL RIGHTS RESERVED.
 *
 *          THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND
 *          COPIED ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH
 *          THE INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE OR ANY
 *          OTHER COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE
 *          AVAILABLE TO ANY OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF THE
 *          SOFTWARE IS HEREBY TRANSFERRED.
 *
 *          THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT
 *          NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY CONDOR
 *          ENGINEERING.
 *
 *============================================================================*
 *
 * FUNCTION:    Source file to go from API -> generic interface
 *
 * Author:      Christopher McKenzie
 * 
 * MAINTENANCE NOTES:
 * 
 *============================================================================*/
#include"interfaces.h"
#include"..\includes\defines.h"
#include"..\includes\canapi.h"
#include"..\includes\irig.h"
#include<string.h>
#include<stdlib.h>
#include<stdio.h>

extern struct _if_channel       channel[CAN_MAXCHANNELS];
extern int if_channel_count;
extern int if_board_count;
extern struct _reftsLink*refts;

#ifdef CANBOARDXL
#include"vector_canboard\vector_canboard.h"
#endif
#ifdef CARDONE
#endif
#ifdef CARDTWO
#endif

struct _s_interface interfaces[]=
{
#ifdef CANBOARDXL
        {       0,
                vector_canboardprobe,
                vector_canboardstartup,
                vector_canboardopenchannel,
                vector_canboardclosechannel,
                vector_canboardshutdown,
                vector_canboardread,
                vector_canboardwrite,
                vector_canboardupdatestatus,
                vector_canboardchangestatus
        },
#endif
#ifdef CARDONE
        {
        },
#endif
#ifdef CARDTWO
        {
        },
#endif
        {       0,0,0,0,0,
                0,0,0,0,0
        }

};
//
// This starts at the beginning if if_channel
// and looks for the first datastructure where 
// the "board" pointer is 0, and assumes that it
// is free from then onward.
//
// Note, boundaries have issues.
//
enum
{       __IFACE,
        __CHAN
};

int boardstartup(int handle,int which)
{       int ret;

        switch(which)
        {       case __CHAN:
                        if(interfaces[channel[handle].board->boardtype].activecount==0)
                        {       ret=interfaces[channel[handle].board->boardtype].startupfunction(handle);
                                if(ret==IF_FAILURE)
                                        return 0;
                                interfaces[channel[handle].board->boardtype].activecount=1;
                        }
                        break;
                case __IFACE:
                        if(interfaces[handle].activecount==0)
                        {       ret=interfaces[handle].startupfunction();
                                if(ret==IF_FAILURE)
                                        return 0;
                                interfaces[handle].activecount=1;
                        }
                        break;
                default:
                        ret=0;
                        break;
        }
        return ret;
}

int boardprobe()
{       int ix;
        long err;
        
        for(ix=0;interfaces[ix].probefunction;ix++)
        {       interfaces[ix].activecount=0;
                boardstartup(ix,__IFACE);
                err=interfaces[ix].probefunction();
                if(err==IF_FAILURE)
                {       printf("board failed\n");
                        return 0;
                }
        }
        return 1;
}

int fakecrc(unsigned char*tocrc,int*fakedcrc)   //FIXME
{       if(!tocrc)
                return 0;
        if(!fakedcrc)
                return 0;

        return 1;
};

int boardopenchannel(int which)
{       int ret;
        boardstartup(which,__CHAN);

        if(channel[which].isopen==0)
        {       ret=interfaces[channel[which].board->boardtype].openchannelfunction(which);
                if(ret==IF_SUCCESS)
                {       channel[which].isopen=1;
                        interfaces[channel[which].board->boardtype].activecount++;
                }
                interfaces[channel[which].board->boardtype].updatestatusfunction(which);
                return ret;
        }
        return 1;
}

int boardread(int which,can_frame*out)
{       int ret;
        boardopenchannel(which);        //won't do double
        ret=interfaces[channel[which].board->boardtype].readfunction(which,out);
        //interfaces[channel[which].board->boardtype].updatestatusfunction(which);
        if(ret==IF_SUCCESS)
                return S_SUCCESS;
        else
                return ret;
}

int boardwrite(int which,can_frame*in)
{       int ret;
        boardopenchannel(which);        //won't do double
        ret=interfaces[channel[which].board->boardtype].writefunction(which,in);
        //interfaces[channel[which].board->boardtype].updatestatusfunction(which);
        if(ret==IF_SUCCESS)
                return S_SUCCESS;
        else
                return ret;
}

int boardupdatestatus(int which)
{       int ret;
        ret=interfaces[channel[which].board->boardtype].updatestatusfunction(which);
        return ret;
}

int boardchangestatus(int handle,int which,int status)
{       int ret;
        ret=interfaces[channel[handle].board->boardtype].changestatusfunction(handle,which,status);
        interfaces[channel[handle].board->boardtype].updatestatusfunction(handle);
        if(ret==IF_SUCCESS)
                return S_SUCCESS;
        else
                return ret;
}

//close all the channels down
int boardshutdown(int which)
{       unsigned int ix;
        for(ix=0;ix<channel[which].board->channelcount;ix++)
        {       interfaces[channel[which].board->boardtype].closechannelfunction(
                        channel[which].board->channel[ix]->index);
        }
        //shutdown the driver
        interfaces[channel[which].board->boardtype].updatestatusfunction(which);
        if(interfaces[channel[which].board->boardtype].activecount==1)
        {       interfaces[channel[which].board->boardtype].shutdownfunction();
                //bring it down
                interfaces[channel[which].board->boardtype].activecount=0;
        }
        return S_SUCCESS;
}
/*
void boarddllmain()
{       static int hasdone=0;
        struct _reftsLink*ref;
        int ix;
        if(hasdone)
                return;

        refts=malloc(sizeof(struct _reftsLink));
        ref=refts;
        refts->index=0;
        for(ix=1;ix<_MAX_IRIG;ix++)
        {       refts->next=malloc(sizeof(struct _reftsLink));
                refts->next->prev=refts;
                refts=refts->next;
                refts->index=ix;
        }
        refts->next=ref;
        ref->prev=refts;
        for(ix=0;ix<_MAX_IRIG*2;ix++)
        {       refts=refts->next;
                printf("%03d ",refts->index);
        }
                for(ix=0;ix<_MAX_IRIG*2;ix++)
        {       refts=refts->prev;
                printf("%03d ",refts->index);
        }
        hasdone=1;
        return;
}
*/

---