/*
 * Common part of gemlib bindings
 *
 *	++jrb	bammi@cadence.com
 *	modified: mj -- ntomczak@vm.ucs.ualberta.ca
 */
#define __IN_COMMON_C
#include "common.h"

/* vdi binding arrays (extern everywhere else) */
unsigned short	_contrl[CNTRLMAX];
short		_intin[INTINMAX];
short		_intout[INTOUTMAX];
short		_ptsin[2 * PTSINMAX];	/* upto PTSINMAX vertices are allowed
					   - currently 1024 */
short		_ptsout[2 * PTSOUTMAX]; /* likewise */

/*
 * aes binding arrays  - we need only global, other overlapped with
 * arrays for vdi - see common.h
 */
unsigned short	_global[GLOBMAX];	/* this should be exact */

/* aes binding params */
void	*_aesparams[6] =	   { (void *)&_control[0],
					 (void *)&_global[0],
				 (void *)&_int_in[0],
				 (void *)&_int_out[0],
				 (void *)&_addrin[0],
				 (void *)&_addrout[0] };
/* why did atari do this when apid is avail on appl_init ?? */
int gl_apid;			/* initialized in appl_init */
int gl_ap_version;		/* initialized in appl_init */

/* vdi binding params */
void	*_vdiparams[5] =	   { (void *)&_contrl[0],
				 (void *)&_intin[0],
				 (void *)&_ptsin[0],
				 (void *)&_intout[0],
				 (void *)&_ptsout[0] };
/*
 * the common interface to aes
 *	int __aes__(coded control);
 *	unsigned long coded control;
 * coded control: (1 byte for each element of control in the long)
 *	DD CC BB AA
 * DD : aes opcode
 * CC : sizeof _int_in
 * BB : sizeof _int_out
 * AA : sizeof _addrin
 *
 * Note: sizeof _addrout is needed only for rsrc_gaddr and is special
 *	 cased below.
 *
 * output: the value (int)_intout[0]
 */

#ifdef __OLD__
int __aes__(unsigned long coded_control)
{
	register unsigned char	*p = (unsigned char *)&coded_control;
	register unsigned short *q = &_control[0];

	/* decode control */
	do
	{
	*q++ = (unsigned short)(*p++);
	} while(q < &_control[4]);

	/* only rsrc_gaddr() needs this */
	*q = (_control[0] == 112) ? 1 : 0;

	/* call aes */
	__asm__ volatile
	("  movl    %0,    d1
		movw	#0xc8, d0
		trap	#2"
	 :				/* no outputs */
	 : "g"(&_aesparams[0])  /* inputs     */
	 : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */
	 );
	return (int)_int_out[0];
}
#else
/*
 * new more efficient coding thanks to Thomas Koenig (UI0T@DKAUNI2.BITNET)
 * "I made use here of the movep instruction for the 680xx, which transfers
 * data from a data register to alternate bytes of memory. The odd
 * address makes sure that these bytes are transferred to the lower half
 * of the words."
 */
int __aes__(unsigned long coded_control)
{

	/* call aes */
	__asm__ volatile
	("  movel   %1,  d1
		lea __contrl, a0	| arrays _contrl and _control overlap
	moveq	#0,  d0
	movepl	d0,  a0@(0) | clear high bytes of control array
		movepl	d1,  a0@(1)
		movl	%0,    d1
		movw	#0xc8, d0	| note -- no movq here, it sign extends
		trap	#2"
	 :				/* no outputs */
	 : "g"(&_aesparams[0]), "g"(coded_control)  /* inputs     */
	 : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */
	 );
	return (int)_int_out[0];
}
#endif

/*
 * the common interface to vdi
 *	void __vdi__(coded contrl, handle);
 *	unsigned long coded contrl;
 *	int handle;
 * coded contrl:
 *	DD BB CC AA
 * DD : subfunc 	(_contrl[5])	5 bits
 * BB : nvert. _ptsin	(_contrl[1])	11 (== # vertices, size = 2 * CC)
 * CC : sizeof _intin	(_contrl[3])	8 bits
 * AA : vdi opcode	(_contrl[0])	8
 *
 * output : void (because it is so inconsistent, individual binding funcs
 *		  will pull info out of the appro. binding arrays)
 */

void __vdi__(unsigned long coded_contrl, int handle)
{
	/* decode contrl */
	_contrl[0] = (unsigned short)(coded_contrl & 0xff);
	_contrl[3] = (unsigned short)((coded_contrl >>= 8) & 0xff);
	_contrl[1] = (unsigned short)((coded_contrl >>= 8) & 0x7ff);
	_contrl[5] = (unsigned short)(coded_contrl >> 11);

	_contrl[6] = handle;

	/* call vdi */
	__asm__ volatile
	("  movl    %0,    d1
		movq	#0x73, d0
		trap	#2"
	 :				/* no outputs */
	 : "g"(&_vdiparams[0])  /* inputs     */
	 : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */
	 );
}

void vdi(void)
{
	__asm__ volatile
	("  movl    %0,    d1
		movq	#0x73, d0
		trap	#2"
	 :				/* no outputs */
	 : "g"(&_vdiparams[0])  /* inputs     */
	 : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */
	 );
}
/* -eof- */