netbox.cpp

一个PPP上网协议源码,可通过GPRS网络接入因特网.

/*////////////////////////////////////////////////////////////////
	Copyright (c) 2001 By Emtronix Incorporated
	5# Gaopeng Road, Chengdu
	Sichuan, P.R.China 610041
	86-28-85140028
	http://www.emtronixinc.com
    **************************************************************

	Filename: NB2003.CPP
	Version:  2.00
	Compiler: Borland3.1
	Date:     13/08/2003

	Description:
	     The definitions of NB2003 lower API functions.

	MODIFICATION HISTORY:

	13-AUG-2003  CS   Created from NB100.cpp
////////////////////////////////////////////////////////////////////*/
#include <stdio.h>
#include <process.h>
#include <dos.h>
#include "netbox.h"

#define	MULTIPLIER	2000L
#define	TMR0SIZE	54925L

#define Port62H		0x62
#define P62_KEYEN	0x80
#define P62_Kout4EN	0x40
#define P62_EXFLG	0x20
#define P62_Kout4SL	0x10
#define P62_Kout3SL	0x08
#define P62_MI_EN	0x04
#define P62_SPI_EN	0x02
#define P62_TriST	0x01

// processor clock = 24MHz
#define	CLK2		24.0e6
#define PWRCON          0xF800

#define P1PIN       	0xF860
#define P1LTC       	0xF862
#define P1DIR       	0xF864
#define P3PIN       	0xF870
#define P3LTC       	0xF872
#define P3DIR       	0xF874
#define P3CFG       	0xF824

static void near dummy (void) {};
unsigned int ReadTimer0( );

#define  EnableExtIO( )		asm	cli;			\
				asm	in	al, 0x23;	\
				asm	mov	ax, 0x8000;	\
				asm	out	0x23, al;	\
				asm	xchg	al, ah;		\
				asm	out	0x22, al;	\
				asm	out	0x22, ax;	\
				asm	sti

#define	DisableExtIO( )		asm	xor	ax, ax;		\
				asm	out	0x23, al

/*///////////////////////////////////////////////////////////
input:
   (1) CSIndex = 0: for CS0#; = 1: for CS1#
   (2) BufSize = 2, 4, 8 in KByte(1024)
   (3) WaitStates = 1 - 31. 1 wait state = 83ns
return:
   a far pointer to the beginning of selected memory
///////////////////////////////////////////////////////////*/
char far* SetCSAsMem( unsigned CSIndex, unsigned BufSize, unsigned WaitStates )
{
   union REGS regs;
   struct SREGS segregs;
   char far* StartAddress;

   AddressEnable( );		// enable A5-A12

   regs.h.ah = 0xe0;
   if( CSIndex > 1 ) CSIndex = 1;
   regs.h.al = (unsigned char)CSIndex;
   if( CSIndex == 0 ) StartAddress = (char far*)MK_FP( 0xac00, 0 );
   else               StartAddress = (char far*)MK_FP( 0xae00, 0 );
   regs.h.bl = 0;
   regs.x.dx = FP_OFF( StartAddress );
   segregs.es = FP_SEG( StartAddress );
   switch( BufSize )
      {
      case 2:  regs.h.cl = 2; break;
      case 4:  regs.h.cl = 4; break;
      case 8:  regs.h.cl = 8; break;
      default: regs.h.cl = 8;
      }
   if( WaitStates > 31 ) regs.h.ch = 31;
   else                  regs.h.ch = WaitStates;

   int86x( 0x15, &regs, &regs, &segregs );

   if( regs.x.cflag == 0 ) return StartAddress;
   else                    return NULL;
}

/*///////////////////////////////////////////////////////////
input:
   (1) CSIndex = 0: for CS0#; = 1: for CS1#
   (2) BasePort = not used IO port, 0x200-0x3FF
       default setting: CS0#: 0x300 - 0x30f
			CS1#: 0x320 - 0x327
   (3) IOSize = 2, 4, 8, 16, 32, 64 in byte
   (4) DataSize = 0: for 8bit; = 1: for 16bit
   (5) WaitStates = 1 - 31. 1 wait state = 42ns
///////////////////////////////////////////////////////////*/
int SetCSAsIO( unsigned CSIndex, unsigned BasePort,
	       unsigned IOSize, unsigned WaitStates )
{
   union REGS regs;

   regs.h.ah = 0xe0;
   if( CSIndex > 1 ) CSIndex = 1;
   regs.h.al = (unsigned char)CSIndex;
   regs.h.bl = 1;
   regs.x.dx = BasePort;
   switch( IOSize )
      {
      case 2:  regs.h.cl = 2;  break;
      case 4:  regs.h.cl = 4;  break;
      case 8:  regs.h.cl = 8;  break;
      case 16: regs.h.cl = 16; break;
      case 32: regs.h.cl = 32; break;
      case 64: regs.h.cl = 64; break;
      default: regs.h.cl = 2;
      }
   if( WaitStates > 31 ) regs.h.ch = 31;
   else                  regs.h.ch = WaitStates;

   int86( 0x15, &regs, &regs );

   if( regs.x.cflag == 0 ) return 0;
   else                    return -1;
}

// Watchdog setup
int EnableWDT( float seconds )
{
   union REGS reg;
   unsigned long value;

   value = (unsigned long)(seconds*CLK2/2.0);
   reg.h.ah=0xe3;
   reg.h.al=0;
   reg.x.dx = (unsigned int)(value>>16);
   reg.x.cx = (unsigned int)(value&0xffff);
   int86(0x15, &reg, &reg);
   if (reg.x.cflag==0) return 0;
   else 	       return -1;
}

//Watchdog reload
int ReloadWDT()
{
   union REGS reg;

   reg.h.ah=0xe3;
   reg.h.al=1;
   int86(0x15, &reg, &reg);
   if (reg.x.cflag==0)  return 0;
   else 		return -1;
}

/*///////////////////////////////////////////////////////////
return = 0: normal boot
       = 1: system boot by watch dog

NOTE: call only once
///////////////////////////////////////////////////////////*/
int GetBootState( )
{
   unsigned char ub1;

   ub1 = inportb( 0x67 );
   outportb( 0x66, 0 );		// clear bootflag
   if( (ub1&0x20) == 0 ) return 0;
   return 1;
}

void SysReboot( )
{
   fcloseall( );
   asm db	0xea
   asm dw	0xfff0
   asm dw	0xf000
}

void NB_Delay( unsigned int milliseconds )
{
   unsigned long stop;
   unsigned cur, prev;

   prev = ReadTimer0( );
   stop = prev + (milliseconds * MULTIPLIER);

   cur = ReadTimer0( );
   while( cur < stop )
      {
      if(cur < prev)     /* Check for timer wraparound */
	 {
	 if (stop < TMR0SIZE) break;
	 stop -= TMR0SIZE;
	 }
      prev = cur;
      cur = ReadTimer0( );
      }
}

unsigned int ReadTimer0( )
{
  asm pushf                    /* Save interrupt flag         */
  asm cli                      /* Disable interrupts          */
  asm mov  al,0h               /* Latch timer 0               */
  asm out  43h,al
      dummy();                 /* Waste some time             */
  asm in   al,40h              /* Counter --> bx              */
  asm mov  bl,al               /* LSB in BL                   */
      dummy();                 /* Waste some time */
  asm in   al,40h
  asm mov  bh,al               /* MSB in BH                   */
  asm mov  ax, 0d68dh          /* */
  asm sub  ax, bx
  asm mov  bx, ax 	       /* Need ascending counter      */
  asm popf                     /* Restore interrupt flag      */
  return( _BX );
}

int EnterPowerSaveMode( )
{
   union REGS reg;

   reg.h.ah=0xe4;
   int86(0x15, &reg, &reg);
   if (reg.x.cflag!=0)  return -1;
   asm hlt
   return 0;
}

/*///////////////////////////////////////////////////////////
// enable GPIO; address bus A5 - A12 disabled
// int 15h  AH = 0E2H
//          AL = 0
///////////////////////////////////////////////////////////*/
void EnableGPIO( )
{
   union REGS reg;

   reg.h.ah=0xe2;
   reg.h.al=0;
   int86(0x15, &reg, &reg);
}

/*///////////////////////////////////////////////////////////
// enable address bus A5 - A12; GPIO disabled
// int 15h  AH = 0E2H
//          AL = 1
///////////////////////////////////////////////////////////*/
void AddressEnable( )
{
   union REGS reg;

   reg.h.ah=0xe2;
   reg.h.al=1;
   int86(0x15, &reg, &reg);
}

/*///////////////////////////////////////////////////////////
input:
   (1) DirByte.D0-D7 = 0: set as output bit;
       DirByte.D0-D7 = 1: set as input bit; default setting
// int 15h  AH = 0E2H
//          AL = 2
//          BL = DirByte
///////////////////////////////////////////////////////////*/
void CfgGPIODir( unsigned char DirByte )
{
   EnableExtIO( );
   outportb( P1DIR, DirByte );
   outportb( P1LTC, inportb( P1LTC)|DirByte );
   DisableExtIO( );

   //union REGS reg;

   //reg.h.ah = 0xe2;
   //reg.h.al = 2;
   //reg.h.bl = DirByte;
   //int86(0x15, &reg, &reg);
}

// int 15h  AH = 0E2H
//          AL = 3
//          BL = OutByte
void SetGPIO( unsigned char OutByte )
{
   EnableExtIO( );
   outportb( P1LTC, inportb(P1DIR)|OutByte );
   DisableExtIO( );

   //union REGS reg;

   //reg.h.ah = 0xe2;
   //reg.h.al = 3;
   //reg.h.bl = OutByte;
   //int86(0x15, &reg, &reg);
}

// int 15h  AH = 0E2H
//          AL = 4
//          BL = OutByte
unsigned char GetGPIO( )
{
   unsigned char ub1;

   EnableExtIO( );
   ub1 = inportb( P1PIN );
   DisableExtIO( );
   return ub1;

   //union REGS reg;

   //reg.h.ah = 0xe2;
   //reg.h.al = 4;
   //int86(0x15, &reg, &reg);
   //return reg.h.bl;
}

/*///////////////////////////////////////////////////////////
// 4X5 keypad enabled (default setting)
///////////////////////////////////////////////////////////*/
void KeypadEnable( )
{
   outportb( Port62H, P62_KEYEN );	// 0x62<--0x80
}

/*///////////////////////////////////////////////////////////
// KIN[0..3] as DI
// KOUT[0..4] as DO
///////////////////////////////////////////////////////////*/
void KIOasDIO( )
{
   outportb( Port62H, 0 );
}

/*///////////////////////////////////////////////////////////
// expanded keypad enabled
///////////////////////////////////////////////////////////*/
void ExpandKeyEnable( )
{
   unsigned char ub1;

   ub1 = inportb( Port62H );
   ub1 |= (P62_KEYEN|P62_EXFLG);
   ub1 &= ~(P62_SPI_EN|P62_MI_EN);
   outportb( Port62H, ub1 );
}

/*///////////////////////////////////////////////////////////
// KOUT4 = COMCLK = 1.846MHz
///////////////////////////////////////////////////////////*/
void ComclkEnable( )
{
   unsigned char ub1;

   ub1 = inportb( Port62H );
   ub1 |= P62_Kout4SL;
   outportb( Port62H, ub1 );
}

/*///////////////////////////////////////////////////////////
// KOUT3 = 24MHz
///////////////////////////////////////////////////////////*/
void CLK24MEnable( )
{
   unsigned char ub1;

   ub1 = inportb( Port62H );
   ub1 |= P62_Kout3SL;
   ub1 &= ~P62_MI_EN;
   outportb( Port62H, ub1 );
}

/*///////////////////////////////////////////////////////////
// SPI interface enable
// input: Mode = 4: 4-wire;
//        Mode = 3: 3-wire; connect KIN0 & KOUT0 together
// KIN0 = DIN		KOUT0 = DOUT
// KIN1 = BUSY		KOUT1 = SCLK
// KIN2 = INTR#         KOUT2 = CS#
///////////////////////////////////////////////////////////*/
void SPI_Enable( )
{
   unsigned char ub1;

   ub1 = inportb( Port62H );
   ub1 |= P62_MI_EN;
   ub1 &= ~(P62_Kout3SL|P62_KEYEN|P62_EXFLG);
   outportb( Port62H, ub1 );
}

// normally as GPRS_AUX
void SetIQR7AsDOUT( int L10 )
{
   unsigned char BIT5, ub1;

   BIT5 = 0x20;
   EnableExtIO( );
   outportb( P3CFG, inportb(P3CFG)&~BIT5 );	// set P3.5 as DIO
   outportb( P3DIR, inportb(P3DIR)&~BIT5 );	// set P3.5 as DOUT
   ub1 = inportb( P3LTC );
   if( L10 )  outportb( P3LTC, (ub1|BIT5)|inportb(P3DIR) );   // set P3.5 = 1
   else       outportb( P3LTC, (ub1&~BIT5)|inportb(P3DIR) );  // set P3.5 = 0
   DisableExtIO( );
}

// normally as GPRS_STB
void SetIRQ6AsDOUT( int L10 )
{
   unsigned char BIT4, ub1;

   BIT4 = 0x10;
   EnableExtIO( );
   outportb( P3CFG, inportb(P3CFG)&~BIT4 );	// set P3.4 as DIO
   outportb( P3DIR, inportb(P3DIR)&~BIT4 );	// set P3.4 as DOUT
   ub1 = inportb( P3LTC );
   if( L10 )  outportb( P3LTC, (ub1|BIT4)|inportb(P3DIR) );   // set P3.4 = 1
   else       outportb( P3LTC, (ub1&~BIT4)|inportb(P3DIR) );  // set P3.4 = 0
   DisableExtIO( );
}

/*
void EnableExtIO( )
{
   asm	cli
   asm  in  al, 0x23;
   asm  mov ax, 0x8000;
   asm  out 23H, al;
   asm  xchg al, ah;
   asm  out 22H, al;
   asm  out 22H, ax;
   asm  sti
}

void DisableExtIO()
{
   asm {
      xor ax,ax
      out 0x23, al }
}

int EnterPowerSaveMode( )
{
   unsigned char IdleMode = 0x02;

   EnableExtIO();
   inportb( PWRCON );
   outportb( PWRCON, IdleMode );
   DisableExtIO();

   asm hlt

   return 0;
}
*/