etr232i.cpp

通过GPRS的PPP拔号程序,本程序在x86下通过测试

#include <dos.h>
#include "etr232i.h"

#define		PIOMODE0	0xFF70
#define		PIODIR0		0xFF72
#define		PIODATA0	0xFF74
#define		PIOMODE1	0xFF76
#define		PIODIR1		0xFF78
#define		PIODATA1	0xFF7A
#define		WDTCTRL		0xFFE6

#define         TMR0CNT		0xFF50
#define		TMR0SIZE	0xF533
#define		MULTIPLIER	1143L
#define	        MaxTick         0x1800be

struct GPIOPos
{
   unsigned int RegIdx;
   unsigned int PosIdx;
};

struct GPIOPos Tab[8] = { { 0, 0 },  { 0, 10 }, { 0, 15 }, { 1, 9 },
			  { 1, 10 }, { 1, 11 }, { 1, 12 }, { 1, 13 } };

unsigned int DatBit[8] = { 0x0001, 0x0400, 0x8000, 0x0200,
			   0x0400, 0x0800, 0x1000, 0x2000 };

// current data register value:
unsigned int DatReg[2] = { 0, 0 };

unsigned int DataTab0[8] = { 0x0000, 0x0001, 0x0400, 0x0401,
			     0x8000, 0x8001, 0x8400, 0x8401 };

// Valid bits: Dir[0], Dir[1], ... Dir[7]
// Dir[i] = 0: output
// Dir[i] = 1: input (default setting)
unsigned char GPIODirCfg( unsigned char Dir )
{
   unsigned int i1, i2, i3;
   unsigned int DirReg[2], ModeReg[2];

   // get current setting:
   ModeReg[0] = inport( PIOMODE0 );
   DirReg[0] = inport( PIODIR0 );
   ModeReg[1] = inport( PIOMODE1 );
   DirReg[1]= inport( PIODIR1 );

   for( i1=0; i1<8; i1++ )
      {
      i2 = 1<<Tab[i1].PosIdx;
      i3 = 1<<i1;
      if( Dir&i3 )		// set as input
	 {
	 ModeReg[Tab[i1].RegIdx] &= ~i2;
	 DirReg[Tab[i1].RegIdx] |= i2;
	 }
      else			// set as output
	 {
	 ModeReg[Tab[i1].RegIdx] |= i2;
	 DirReg[Tab[i1].RegIdx] &= ~i2;
	 }
      }

   outport( PIOMODE0, ModeReg[0] );
   outport( PIODIR0, DirReg[0] );
   outport( PIOMODE1, ModeReg[1] );
   outport( PIODIR1, DirReg[1] );
   return 0;
}

// Valid bits: Value[0], Value[1], ... Value[7]
void  GPIOWrite( unsigned char Value )
{
   unsigned int  i1, i2;
   unsigned char ub1;

   disable( );

   DatReg[0] = DataTab0[Value&0x07];
   i2 = ((unsigned int)Value)&0x00f8;
   DatReg[1] = i2<<6;

   outport( PIODATA0, DatReg[0] );
   outport( PIODATA1, DatReg[1] );

   enable( );
}

// return input status
unsigned char GPIORead( )
{
   unsigned int  CurrDat[2];
   unsigned char ub1, ub2;

   // current value
   CurrDat[0] = inport( PIODATA0 );
   CurrDat[1] = inport( PIODATA1 );

   // processing lower 3-bit
   CurrDat[0] &= 0x8401;
   switch( CurrDat[0] )
      {
      case 0x0000: ub1 = 0; break;
      case 0x0001: ub1 = 1; break;
      case 0x0400: ub1 = 2; break;
      case 0x0401: ub1 = 3; break;
      case 0x8000: ub1 = 4; break;
      case 0x8001: ub1 = 5; break;
      case 0x8400: ub1 = 6; break;
      case 0x8401: ub1 = 7; break;
      }

   // processing higher 5-bit
   CurrDat[1] &= 0x3e00;
   ub2 = (unsigned char)(CurrDat[1]>>6);

   // combine together
   ub2 |= ub1;
   return ub2;

   /*
   unsigned int  i1, i2, i3, i4;
   // current value
   CurrDat[0] = inport( PIODATA0 ) & inport( PIODIR0 );
   CurrDat[1] = inport( PIODATA1 ) & inport( PIODIR1 );

   i4 = 0;
   for( i1=0; i1<3; i1++ )		// processing PIO0
	  {
	  i3 = 1<<i1;
	  if( CurrDat[0]&DatBit[i1] )  i4 |= i3;	// set as 1
	  else						   i4 &= ~i3;	// set as 0
	  }

   for( ; i1<8; i1++ )          // processing PIO1
	  {
	  i3 = 1<<i1;
	  if( CurrDat[1]&DatBit[i1] )  i4 |= i3;	// set as 1
	  else						   i4 &= ~i3;	// set as 0
	  }

   return (unsigned char)i4;
   */
}

// BitIdx = 0, 1, ...7
unsigned int GPIOSetBit( int BitIdx, int L10 )
{
   unsigned int  i1, i2;

   disable( );
   i2 = DatBit[BitIdx];
   if( BitIdx <= 2 )
      {
      if( L10 ) DatReg[0] |= i2;
      else      DatReg[0] &= ~i2;
      outport( PIODATA0, DatReg[0] );
      }
   else
      {
      if( L10 ) DatReg[1] |= i2;
      else      DatReg[1] &= ~i2;
      outport( PIODATA1, DatReg[1] );
      }
   enable( );

   return 0;
}

// L10 = 0, 1
void  GPRS_STB( int L10 )
{
   unsigned int  DatReg;

   disable( );
   // get current value
   DatReg = inport( PIODATA0 );

   if( L10 ) DatReg |= 0x2000;
   else      DatReg &= 0xdfff;

   outport( PIODATA0, DatReg );
   enable( );
}

// return = 0, 1
unsigned int GPRS_PWR( )
{
   unsigned int  DatReg;

   // get current value
   DatReg = inport( PIODATA0 ) & inport( PIODIR0 );

   if( DatReg&0x0008 ) return 1;
   return 0;
}

// L10 = 0, 1
void  GPRS_AUX( int L10 )
{
   if( L10 ) outportb( 0x23, 0x03 );
   else      outportb( 0x23, 0x01 );
}

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

   prev = inport( TMR0CNT );
   stop = prev + ((unsigned long)milliseconds * MULTIPLIER);

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

// timer1's input clock = 1MHz
int SetTMR1( unsigned Divider )
{
   unsigned ub1;

   ub1 = Divider / 2;
   outport( 0xff5a, ub1 );
   ub1 = Divider - ub1;
   outport( 0xff5c, ub1 );
   return 0;
}

void SysReboot( )
{
   disable( );
   outport( 0xff28, 0x07fd );        // mask all interrupts
   asm db	0xea
   asm dw	0xfff0
   asm dw	0xf000
}
unsigned int WDTReg = 0;
////////////////////////////////////////////////////////
// watchdog duration time = 1exp2(ExpNum)/24.0MHz
// ExpNum = 0: disable WDT
// ExpNum = 25, 26: enable WDT
////////////////////////////////////////////////////////
int   SetWDT( int ExpNum )
{
   switch( ExpNum )
      {
      case 25: WDTReg = 0xc040; break;          // enable WDT
      case 26: WDTReg = 0xc080; break;          // enable WDT
      default: WDTReg = 0;			// disable WDT
      }

   outport( WDTCTRL, 0x3333 );		// keyed sequence for writing
   outport( WDTCTRL, 0xCCCC );
   outport( WDTCTRL, WDTReg );

   outport( WDTCTRL, 0x5555 );		// keyed sequence for reading
   outport( WDTCTRL, 0xAAAA );
   if( inport(WDTCTRL)&0x8000 ) return 1;
   return 0;
}

int   ReloadWDT( )
{
//   outport( WDTCTRL, 0x3333 );		// keyed sequence for writing
//   outport( WDTCTRL, 0xCCCC );
//   outport( WDTCTRL, WDTReg );

   outport( WDTCTRL, 0x5555 );		// keyed sequence for reading
   outport( WDTCTRL, 0xAAAA );
   if( inport(WDTCTRL)&0x8000 ) return 1;
   return 0;
}

int  NB_CLKFlag = 0;
int  NB_DayCnt = 0;
unsigned long NB_PrevTick;

unsigned long NB_clock( )
{
   unsigned long currtick;

   disable( );
   currtick = *((unsigned long far*)(0x0040006Cl));
   enable( );

   if( NB_CLKFlag == 0 )	// the first time
      {
      NB_PrevTick = currtick;
      NB_DayCnt = 0;
      NB_CLKFlag = 1;
      }
   else				// the normal case
      {
      if( currtick < NB_PrevTick ) NB_DayCnt += 1;
      NB_PrevTick = currtick;
      }

   currtick = NB_PrevTick + ((long)NB_DayCnt*MaxTick);
   return currtick;	//overflow happens after 2730 days since power on!!!
}