initcard.c

实现vxworks下的1553b通讯功能

#include <string.h>
#include "proto.h"
#include <intLib.h>
#include <pc.h>
#include <iv.h>
#include <configInum.h>

#define EXC_REGISTER_RESET		0x0
#define EXC_REGISTER_SETBANK		0x02
#define EXC_REGISTER_INTERRUPT		0x03

typedef struct
{
	int enabled;
	VOIDFUNCPTR interruptFunc;

} INSTANCE_MCH_INTERRUPT;
static INSTANCE_MCH_INTERRUPT mch_interrupt[Max_Channels];

/* for use by select_Channel */
static short curmsg[ Max_Channels ]    = {0,0,0,0,0,0,0,0};
static short milstd[ Max_Channels ]    = {1,1,1,1,1,1,1,1};
short exists[ Max_Channels ]    = {1,1,1,1,1,1,1,1};

struct exc_bd * exc_summit;
unsigned short  * exc_summit_int;
struct bm_command_block  * bm_command_blocks; /* monitor command blocks */
struct bc_command_block  * bc_command_blocks; /* BC command blocks */
short curmode, nextmsg;
unsigned short curchan = 0;
short milstd1553B = 1;
int gIOport, intnum;
volatile usint wForceWordWrite;
unsigned short int gdevice;
int int_connected=0;

int borland_dll Init_Card_MCH (unsigned short device, unsigned short ioport)
{
	int iError,i;
	usint j;

	if ((device < 0xc0) || (device > 0xe8))
		return einval;

	gIOport = ioport;
	gdevice = device;

	exc_summit_int = (unsigned short *)(device << 12);  
 	exc_summit = (struct exc_bd *)(exc_summit_int);
	bm_command_blocks = (struct bm_command_block  *)&exc_summit_int[INIT_MON_BLK];
	bc_command_blocks = (struct bc_command_block  *)&exc_summit_int[CMDOFFSET];

	Select_Channel(0); /* Assume at least one channel */

	/* Test first bank of memory in channel 0 */
	for (i=Start_DPRAM; i<BANKSIZE; i++)
	{
		exc_summit_int[i] = Clear_Pattern;
		if ((exc_summit_int[i]) != Clear_Pattern)
			return (ememerr);
	}

	for (j=1; j<Max_Channels; j++)
	{
		exc_summit_int[Start_DPRAM] = j;
		Select_Channel(j);
		if (exc_summit_int[Start_DPRAM] == j)
			exists[j] = 0;
		else
		{
			iError = Get_Channel_Status(j);
			if (iError == 0)
				exists[j] = 0;
			else
				exists[j] = 1;
		}
 	}
	Select_Channel(0);
	return 0;
} /* end Init_Card */


int borland_dll Release_Card_MCH (void)
{
	return 0;
}

int Set_Bank(int iBankNo) 
{
	if (iBankNo >= (Max_Channels * 2))
	   	return einval;
	sysOutByte(gIOport + EXC_REGISTER_SETBANK, (unsigned char) iBankNo);
	return 0;
}

int  borland_dll Select_Channel (unsigned short channel)
{
   /* check for valid parameters */
   if (channel >= Max_Channels)
	return einval;
   if ( exists[channel] == 0)
   	return ebadchan;

   Set_Bank(channel*2);  /* select lower bank of channel */

   curmsg[curchan] = nextmsg;
   nextmsg = curmsg[channel];
   milstd[curchan] = milstd1553B;
   milstd1553B = milstd[channel];
   curmode = (unsigned short)(exc_summit->status & MSEL);
   curchan = channel;
   return 0;
} /* end Select_Channel */

int Reset_Channel(unsigned short channel) 
{
	if (channel >= Max_Channels)
		return einval;
	if (exists[channel] == 0)
	  	return ebadchan;
	sysOutByte(gIOport + EXC_REGISTER_RESET, (unsigned char)(channel + 1));
	return 0;
}

int borland_dll Set_Interrupt_Level (int irq)
{
	/* check for valid values */
	if ((irq < 1) || ((irq > 7) && (irq < 10)) || (irq == 13) || (irq > 15))
		return einval;
	intnum = irq;
	return 0;
}

int  borland_dll Reset_Interrupt (unsigned char interrupt_channels)
{
	sysOutByte(gIOport + EXC_REGISTER_INTERRUPT, interrupt_channels);
	return 0;
} 

int borland_dll Get_Interrupt_Channels (unsigned char *intchan)
{
	*intchan = sysInByte(gIOport + EXC_REGISTER_INTERRUPT);
	return 0;
}


int SetupInterruptHandler(VOIDFUNCPTR funcname)
{
	return Exc_SetupInterruptHandler_MCH(curchan,funcname);
}

int ClearInterruptHandler(void)
{
	return Exc_ClearInterruptHandler_MCH(curchan);
}

void InterruptHandler_MCH(void)
{
	int original_channel, channel;
	unsigned short int intBit;
	unsigned char intchan;

	original_channel = curchan;

	Get_Interrupt_Channels (&intchan);
	for (channel=0; channel<Max_Channels; channel++)
	{
		intBit = 1<<channel;
		if (intchan & intBit)
		{
			if (mch_interrupt[channel].interruptFunc != NULL)
			{
				if (curchan != channel)
					Select_Channel(channel);

				(mch_interrupt[channel].interruptFunc)();

			}
		}
	}
	if (curchan != original_channel)
		Select_Channel(original_channel);

	Reset_Interrupt(intchan);/* reset interrupt */
	return;
}

int Exc_SetupInterruptHandler_MCH(unsigned short int channel, VOIDFUNCPTR funcname)
{
	int i, connected, iError;
	connected = 0;

	for (i=0; i<Max_Channels; i++)  
	{
		/* if any initialized channels on card already assigned interrupt func, don't need to do intConnect */
		if (mch_interrupt[i].enabled == 1)
		{
			connected = 1;
			break;
		}
	}
	if (!connected)
	{
		iError = intConnect(INUM_TO_IVEC(INT_NUM_IRQ0 + intnum),(VOIDFUNCPTR)InterruptHandler_MCH, 0);
 	   	iError = sysIntEnablePIC(intnum);
	}

	mch_interrupt[channel].enabled = 1;
	mch_interrupt[channel].interruptFunc = funcname;
	return 0;

}

int Exc_ClearInterruptHandler_MCH(unsigned short int channel)
{
	int i, connected, iError;

	if (mch_interrupt[channel].enabled != 0)
	{
	        mch_interrupt[channel].enabled = 0;
		mch_interrupt[channel].interruptFunc = NULL;

		connected = 0;
		for (i=0; i<Max_Channels; i++)
		{
			if (mch_interrupt[i].enabled != 0)
			{
				connected = 1;
				break;	
			}
		}
		if (!connected)
	 	   	iError = sysIntDisablePIC(intnum);
	}
	return 0;
}