/***************************************************************************/
/*										*/
/*			  	PROXIM RANGELAN2 LOW LEVEL DRIVER		*/
/*										*/
/*		PROXIM, INC. CONFIDENTIAL AND PROPRIETARY.  This source is the	*/
/*		sole property of PROXIM, INC.  Reproduction or utilization of	*/
/*		this source in whole or in part is forbidden without the written*/
/*		consent of PROXIM, INC.						*/
/*										*/
/*										*/
/*				(c) Copyright PROXIM, INC. 1994			*/
/*					All Rights Reserved			*/
/*										*/
/***************************************************************************/

/***************************************************************************/
/*										*/
/*	$Header:   J:\pvcs\archive\clld\asm.c_v   1.20   27 Sep 1996 09:03:38   */
/*										*/
/*										*/
/*										*/
/***************************************************************************/

#include <asm/system.h>
#include <asm/io.h>
#include <linux/delay.h>
/*
#include	<stdio.h>
#include "constant.h"
*/
#include "lld.h"
#include	"asm.h"

#ifdef MULTI
#include "bstruct.h"
#include "pstruct.h"
#ifdef SERIAL
#include "slld.h"
#include "slldbuf.h"
#endif
#include	"multi.h"

extern struct LLDVarsStruct	*LLDVars;

#else
extern unsigned_8					LLDDebugFlag;
#endif


#define	COLOR			1
#define	MinCursor	80 * 27 * 2
#define	MaxCursor   80 * 48 * 2

unsigned_16		Cursor = MinCursor;
unsigned_16		ScreenColumn;
/***************************************************************************/
/*	_outp, _outw, _inp, _inpw                                          */
/*                                                                         */      
/*      in/out byte/word assembly commands used by the library.            */
/*      Mapped into the equivalent linux subroutines.                      */
/*                                                                         */
/***************************************************************************/
_outp(a,b)
{
        outb(b,a);
}

_outpw(a,b)
{
        outw(b,a);
}

_inp(a)
{
        inb(a);
}

_inpw(a)
{
        inw(a);
}




/***************************************************************************/
/*																									*/
/*	Delay (millitime)																			*/
/*																									*/
/*	INPUT:	millitime -	Number of milliseconds to delay. 						*/
/*																									*/
/*	OUTPUT:																						*/
/*																									*/
/*	DESCRIPTION: This routine calls a BIOS function to delay the required	*/
/*              number of milliseconds.												*/
/*																									*/
/***************************************************************************/

void Delay (unsigned_16 millitime)
{
        int i;
        for(i=0; i<millitime; i++)
          udelay(1000);
}


/***************************************************************************/
/*																									*/
/*	Delay_uS (microtime)																		*/
/*																									*/
/*	INPUT:	microtime -	Number of microseconds to delay. 				  		*/
/*																									*/
/*	OUTPUT:																						*/
/*																									*/
/*	DESCRIPTION: This routine calls a BIOS function to delay the required	*/
/*              required number of microseconds.									*/
/*																									*/
/***************************************************************************/

void Delay_uS (unsigned_16 microtime)
{
        udelay(microtime);
}


/***************************************************************************/
/*																									*/
/*	OutString (*string, ColorCode)					 									*/
/*																									*/
/*	INPUT:  string - The null terminated string of characters we want			*/
/*                  displayed.															*/
/*         ColorCode - The character's color.										*/
/*																									*/
/*	OUTPUT:																						*/
/*																									*/
/*	DESCRIPTION: This routine will print the character on the screen.			*/
/*																									*/
/***************************************************************************/

void OutString (char *string, unsigned_8 ColorCode)
{
	while (*string)
	{
		OutChar (*string, ColorCode);
		*string++;
	}
}

/***************************************************************************/
/*																									*/
/*	OutChar (Character, ColorCode)					 									*/
/*																									*/
/*	INPUT:  Character - The character we want displayed.							*/
/*         ColorCode - The character's color.										*/
/*																									*/
/*	OUTPUT:																						*/
/*																									*/
/*	DESCRIPTION: This routine will print the character on the screen.			*/
/*																									*/
/***************************************************************************/

void OutChar (unsigned_8 Character, unsigned_8 ColorCode)

{
/*	printk("%c",Character);
*/
/*	if (LLDDebugFlag == COLOR)
	{	
		__asm		pushf
		__asm		push	es
		__asm		push	di
		__asm		push	ax
		__asm		push	bx

		__asm		cld

		__asm		mov	ax, 0B800H
		__asm		mov	es, ax

		__asm		mov	di, Cursor
		__asm		mov	al, Character
		__asm		stosb
		__asm		mov	bl, ColorCode
		__asm		mov	es: byte ptr [di], bl
		__asm		inc	di
		__asm		cmp	di, MaxCursor
		__asm		jb		DontDecrement
		__asm		mov	di, MinCursor

	DontDecrement:
		__asm		mov	Cursor, di
		__asm		mov	es: byte ptr [di], '*'
		__asm		mov	es: byte ptr [di + 1], 0f4h

		__asm		pop	bx
		__asm		pop	ax
		__asm		pop	di
		__asm		pop	es
		__asm		popf
	}
*/}



/***************************************************************************/
/*																									*/
/*	Beep (Frequency)																			*/
/*																									*/
/*	INPUT:	Frequency	-	Frequency to beep at.									*/
/*																									*/
/*	OUTPUT:																						*/
/*																									*/
/*	DESCRIPTION: This routine will turn the speaker on at the specified		*/
/*              frequency.		  															*/
/*																									*/
/***************************************************************************/

void Beep (unsigned_16 Frequency)

{/* 	__asm		push	ax
	__asm		push	bx
	__asm		push	dx
	__asm		pushf
	__asm		cli
	__asm		mov	bx, Frequency
	__asm		mov	al, 0B6h
	__asm		out	043h, al
	__asm		xor	ax, ax
	__asm		cmp	bx, 20
	__asm		jb		Sound_On_1
	__asm		mov	dx, 012h
	__asm		mov	ax, 034DEh
	__asm		div	bx

	Sound_On_1:
	__asm		out	042h, al
	__asm		mov	al, ah
	__asm		push	ax
	__asm		in	al, 61h
	__asm		in	al, 61h
	__asm		in	al, 61h
	__asm		pop	ax
	__asm		out	042h, al
	__asm		in		al, 061h
	__asm		or		al, 3
	__asm		push	ax
	__asm		in	al, 61h
	__asm		in	al, 61h
	__asm		in	al, 61h
	__asm		in	al, 61h
	__asm		in	al, 61h
	__asm		in	al, 61h
	__asm		pop	ax
	__asm		out	061h, al
	__asm		popf
	__asm		pop	dx
	__asm		pop	bx
	__asm		pop	ax

	Delay (84);

	__asm		push 	ax
	__asm		pushf
	__asm		cli
	__asm		in	  	al, 061h
	__asm		and	al, 11111100b
	__asm		push	ax
	__asm		in	al, 61h
	__asm		in	al, 61h
	__asm		in	al, 61h
	__asm		in	al, 61h
	__asm		in	al, 61h
	__asm		in	al, 61h
	__asm		pop	ax
	__asm		out	061h, al
	__asm		popf
	__asm		pop	ax
*/}



/***************************************************************************/
/*																									*/
/*	PreserveFlag ()																			*/
/*																									*/
/*	INPUT:			 																			*/
/*																									*/
/*	OUTPUT:				Current flags														*/
/*																									*/
/* DESCRIPTION:		This routine returns the current processor flags.		*/
/*																									*/
/***************************************************************************/

FLAGS PreserveFlag (void)
{
	FLAGS	oldflag;

        save_flags(oldflag);
/*	__asm		pushf
	__asm		pop	ax	
	__asm		mov	oldflag, ax
*/
	return (oldflag);
}


/***************************************************************************/
/*																									*/
/*	RestoreFlag ()																				*/
/*																									*/
/*	INPUT:				Previously preserved flag										*/
/*																									*/
/*	OUTPUT:			 																			*/
/*																									*/
/* DESCRIPTION:		Restore the previously preserved processor flags.     */
/*																									*/
/***************************************************************************/

void RestoreFlag (FLAGS OrigFlag)
{
        restore_flags(OrigFlag);
/*	__asm		push	ax

	__asm		mov	ax, OrigFlag
	__asm		push	ax
	__asm		popf		

	__asm		pop	ax
*/
}


/***************************************************************************/
/*																									*/
/*	EnableInterrupt ()																		*/
/*																									*/
/*	INPUT:			 																			*/
/*																									*/
/*	OUTPUT: 			 																			*/
/*																									*/
/*	DESCRIPTION: This function enables the processor's interrupts.				*/
/*																									*/
/***************************************************************************/

void EnableInterrupt (void)
{
/*
	enable_irq (LLDIntLine1);
	sti();
	__asm		sti
*/}



/***************************************************************************/
/*																									*/
/*	DisableInterrupt ()																		*/
/*																									*/
/*	INPUT:																						*/
/*																									*/
/*	OUTPUT:																						*/
/*																									*/
/*	DESCRIPTION: This function disables the processor's interrupts.			*/
/*																									*/
/***************************************************************************/
 
void DisableInterrupt (void)
{
/*	
	disable_irq (LLDIntLine1);
	cli();
	__asm		cli 
*/}

/***************************************************************************/
/*																									*/
/*	OutHexL (HexLong, ColorCode)    														*/
/*																									*/
/*	INPUT:  The 32-bit hexadecimal number we want displayed.						*/
/*         The number's color.															*/
/*																									*/
/*	OUTPUT:																						*/
/*																									*/
/*	DESCRIPTION: This routine will print the Hex number to the screen			*/
/*																									*/
/***************************************************************************/

void OutHexL (unsigned_32 HexLong, unsigned_8 ColorCode)

{
	OutHex ((unsigned_8)(HexLong >> 24), ColorCode);
	OutHex ((unsigned_8)(HexLong >> 16), ColorCode);
	OutHex ((unsigned_8)(HexLong >>  8), ColorCode);
	OutHex ((unsigned_8)(HexLong >>  0), ColorCode);
}

/***************************************************************************/
/*																									*/
/*	OutHexW (HexWord, ColorCode)   														*/
/*																									*/
/*	INPUT:  The 16-bit hexadecimal number we want displayed.						*/
/*         The number's color.															*/
/*																									*/
/*	OUTPUT:																						*/
/*																									*/
/*	DESCRIPTION: This routine will print the Hex number to the screen			*/
/*																									*/
/***************************************************************************/

void OutHexW (unsigned_16 HexWord, unsigned_8 ColorCode)

{
	OutHex ((unsigned_8)(HexWord >>  8), ColorCode);
	OutHex ((unsigned_8)(HexWord >>  0), ColorCode);

}


/***************************************************************************/
/*																									*/
/*	OutHex (HexByte, ColorCode)  	 														*/
/*																									*/
/*	INPUT:  The 8-bit hexadecimal number we want displayed.		 				*/
/*         The number's color.															*/
/*																									*/
/*	OUTPUT:																						*/
/*																									*/
/*	DESCRIPTION: This routine will print the Hex number to the screen			*/
/*																									*/
/***************************************************************************/

void OutHex (unsigned_8 HexByte, unsigned_8 ColorCode)

{
/*	printk("%h",HexByte);
*/
/*	unsigned_8	Abyte;

	if (LLDDebugFlag == COLOR)
	{	
		__asm		push	ax

		__asm		mov	al, HexByte
		__asm		push	ax							

		__asm		and	al, 011110000b	

		__asm		shr	al, 1
		__asm		shr	al, 1
		__asm		shr	al, 1
		__asm		shr	al, 1

		__asm		cmp	al, 9
		__asm		jbe	LLDISR_NP1							
		__asm		add	al, 'A'-10		
		__asm		jmp	LLDISR_NP1a

	LLDISR_NP1:
		__asm		add	al, 030h								

	LLDISR_NP1a:
		__asm		mov	Abyte, al

		OutChar (Abyte, ColorCode);

		__asm		pop	ax

		__asm		and	al, 00001111b
		__asm		cmp	al, 9
		__asm		jbe	LLDISR_NP2
		__asm		add	al, 'A'-10
		__asm		jmp	LLDISR_NP2a

	LLDISR_NP2:
		__asm		add	al, 030h

	LLDISR_NP2a:
		__asm		mov	Abyte, al

		OutChar (Abyte, ColorCode);

		__asm		pop	ax
	}

*/}