hal4sys.c

该软件源程序示范了如何在嵌入式系统中实现USB-OTG协议

/*
   //*************************************************************************
   //
   //                  P H I L I P S   P R O P R I E T A R Y
   //
   //           COPYRIGHT (c)   2005 BY PHILIPS SINGAPORE.
   //                     --  ALL RIGHTS RESERVED  --
   //
   // Project:		ISP1302 Eva Kit
   // File Name:	HAL4sys.c
   // Author:		Guo Yang Bin, Email: [e-mail]
   // Created:		Nov 20, 2005
   // Modified:
   // Revision:		1.1
   //*************************************************************************
*/

#include <stdio.h>
#include <dos.h>

#include "BasicTyp.h"
#include "hal4sys.h"
#include "isr.h"
/*
//*************************************************************************
//  Public static data
//*************************************************************************
*/
ULONG   Hal4Sys_ClockTicks = 0;
unsigned char far *privateBuffer;

/*
//*************************************************************************
//  Private static data
//*************************************************************************
*/
USHORT D09PCKIT_PORTBASE;
UCHAR Hal4Sys_SysCtrl_PORT = 0;
USHORT D09PCKIT_PORTBASE;
extern D09FLAGS bD09flags;
UCHAR inten_state,speed=0;
//#define MK_FP(seg, ofs)     ( (void __far *) ((((unsigned long)(seg)) << 16) + (ofs)))

/*
//*************************************************************************
//  Subroutines
//*************************************************************************
*/
void interrupt (*Hal4Sys_OldIsr4Timer)();

void get_addresses(void)
{
    D09PCKIT_PORTBASE = *((int far *)MK_FP(0x40, 0x08));
}


void Hal4Sys_End_Int(void)   // end of interrupt routine
{
	outportb(0x20,0x20);
}

void Hal4Sys_Initial_uP(void)
{
	Hal4Sys_SysCtrl_PORT = 0;

	Hal4Sys_AcquireTimer0();
}

void Hal4Sys_Release_uP(void)
{
	Hal4Sys_ReleaseTimer0();
    Hal4Sys_End_Int();
	farfree(privateBuffer);
}

// this function added for reset and set the clock synchronization.
void Hal4Sys_ResetPCBA(void)
{      
	Hal4Sys_SysCtrl_PORT &= ~SCP_RST;//	Hal4Sys_SysCtrl_PORT  |= SCP_RST;
	outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); //
    Hal4Sys_WaitinUS(50);
	Hal4Sys_SysCtrl_PORT  |= SCP_RST;
	outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); // reset all PCBA
    Hal4Sys_WaitinUS(9000);
	Hal4Sys_SysCtrl_PORT &= ~SCP_RST;
	outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); // reset release
}
UCHAR Hal4Sys_PowerDet(void)
{      
    UCHAR temp;
	outportb(D09_SYSCTRL_PORT,0x80); //
  //  Hal4Sys_WaitinUS(10);
    temp = inportb(D09_INPUT_PORT)&0x10;
	if(temp)
	{
    	outportb(D09_SYSCTRL_PORT,0x00); //
    //    Hal4Sys_WaitinUS(10);
        temp = inportb(D09_INPUT_PORT)&0x10;
        if(temp==0)
		{
        	outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); 
			return 1;
		}
		else
		{
			outportb(D09_SYSCTRL_PORT,0); 
            outportb(D09_INOUT_PORT,0); 
						return 0;
		}
	}
	else 
	{
		outportb(D09_SYSCTRL_PORT,0); // reset release
		outportb(D09_INOUT_PORT,0); 
						return 0;
	}
}
void Hal4Sys_Set_pule(void)
{      
	Hal4Sys_SysCtrl_PORT  |= SCP_SPEED;
	outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); //
    Hal4Sys_WaitinUS(50);
	Hal4Sys_SysCtrl_PORT &= ~SCP_SPEED;
	outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); // reset all PCBA
    Hal4Sys_WaitinUS(9000);
	Hal4Sys_SysCtrl_PORT |= SCP_SPEED;
	outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); // reset release
}
void interrupt Hal4Sys_Isr4Timer(void)
{
	Hal4Sys_ClockTicks++;

	(*Hal4Sys_OldIsr4Timer)();
}

void Hal4Sys_ReleaseTimer0(void)
{
	setvect(0x8, Hal4Sys_OldIsr4Timer);
}

void Hal4Sys_AcquireTimer0(void)
{
	Hal4Sys_OldIsr4Timer = getvect(0x8);
	setvect(0x8, Hal4Sys_Isr4Timer);
}


#define MACHINE_CYCLE 50

void Hal4Sys_WaitinUS(IN OUT ULONG time)
{
	ULONG loop;
	for(loop =time*MACHINE_CYCLE;loop>0 ;loop--)
	{
		continue;
	}

}

void Hal4Sys_WaitinMS(
	 IN OUT ULONG time
)
{
    ULONG i;
	for(i=0; i<time; i++)
	{
		Hal4Sys_WaitinUS(16*1000);
	}
}



void Hal4Sys_ControlD09Interrupt(BOOLEAN InterruptEN)
{
	if(InterruptEN)
    {

		inten_state = 0x80;
    }
    else
    {

		inten_state = 0;
    }

//	outportb(D09_ADDRESS_PORT,inten_state);

}
//I2C soft host 
void CLK_SCL_H(void)
{

       Hal4Sys_SysCtrl_PORT  &= ~SCP_SCL;
       outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); 
       Hal4Sys_WaitinUS(speed);
}
void CLK_SCL_L(void)
{
       Hal4Sys_SysCtrl_PORT  |=  SCP_SCL;
       outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); 
       Hal4Sys_WaitinUS(speed);
}

void MOSI_SDA_H(void)
{
       outportb(D09_INOUT_PORT,1); 
       Hal4Sys_WaitinUS(speed);
}
void MOSI_SDA_L(void)
{

       outportb(D09_INOUT_PORT,4); 
       Hal4Sys_WaitinUS(speed);
}


void Hal4Sys_i2c_start(void)
{
       CLK_SCL_H();
       MOSI_SDA_H();

       MOSI_SDA_L();

       CLK_SCL_L();
}
UCHAR Hal4Sys_i2c_get_address(void)
{
	   if(bD09flags.bits.adr_state)
   	   return 0x58;
	   else
   	   return 0x5A;
}
void Hal4Sys_i2c_send_data(UCHAR data)
{
   UCHAR i,temp;
	   for(i=0; i<8; i++)
	   {
           temp = (data<<i)&0x80;
           if(temp)
            MOSI_SDA_H(); 
		   else
            MOSI_SDA_L(); 
           CLK_SCL_H();
           CLK_SCL_L();
	   }
}
void Hal4Sys_i2c_ack(void)
{
   UCHAR i=0, temp;
	   i=0;
       MOSI_SDA_H(); 
       CLK_SCL_H();
	do{
         temp = inportb(D09_INPUT_PORT)&0x20;
	   if(temp==0)
	   {
    	   i++;
    	   if(i>20)
		   {
    		   printf("i2c no ack");
    		   break;
		   }
	   }
	   else
		   break;

	   }while(1);
       CLK_SCL_L();  
       Hal4Sys_WaitinUS(10);	   
}

void Hal4Sys_i2c_noack(void)
{
       MOSI_SDA_H(); 
       CLK_SCL_H();
 
       CLK_SCL_L();	   
}

void Hal4Sys_i2c_stop(void)
{
       MOSI_SDA_L(); 
       CLK_SCL_L();

       CLK_SCL_H(); 
       MOSI_SDA_H(); 
	   
}
UCHAR Hal4Sys_i2c_get_data(void)
{
   UCHAR i,data,temp;
    data = 0;
	for(i=0; i<8; i++)
	{
       CLK_SCL_H();
       temp = ((~inportb(D09_INPUT_PORT))>>5)&0x01;
	   data =(data<<1)|temp;
       CLK_SCL_L();
	}
	return data;
}
UCHAR Hal4Sys_Read(UCHAR address)
{
	UCHAR i2c_address,data;
 
	if(bD09flags.bits.bus_state)
	{
   	   i2c_address = Hal4Sys_i2c_get_address();

	   Hal4Sys_i2c_start();
       Hal4Sys_i2c_send_data(i2c_address);
       Hal4Sys_i2c_ack();
       Hal4Sys_i2c_send_data(address);
       Hal4Sys_i2c_ack();

	   Hal4Sys_i2c_start();
       Hal4Sys_i2c_send_data(i2c_address|1);
       Hal4Sys_i2c_ack();
       data=Hal4Sys_i2c_get_data();
       Hal4Sys_i2c_noack();
       Hal4Sys_i2c_stop();
	}
	else
	{
       Hal4Sys_SPI_start();
       Hal4Sys_SPI_address(address);
       Hal4Sys_SPI_null();
       data= Hal4Sys_SPI_getdata();
	   Hal4Sys_SPI_stop();
	}
	return data;

}

void Hal4Sys_Write(UCHAR data, UCHAR address)
{
	UCHAR i2c_address;
	if(bD09flags.bits.bus_state)
	{
   	   i2c_address = Hal4Sys_i2c_get_address();
	   Hal4Sys_i2c_start();
       Hal4Sys_i2c_send_data(i2c_address);
       Hal4Sys_i2c_ack();
       Hal4Sys_i2c_send_data(address);
       Hal4Sys_i2c_ack();

       Hal4Sys_i2c_send_data(data);
       Hal4Sys_i2c_ack();
       Hal4Sys_i2c_stop();
	}	
	else
	{
       Hal4Sys_SPI_start();
       Hal4Sys_SPI_address(address|0X20);
       Hal4Sys_SPI_null();
       Hal4Sys_SPI_senddata(data);
	   Hal4Sys_SPI_stop();
	}
}

void Hal4Sys_SPI_start(void)
{
     Hal4Sys_SysCtrl_PORT  |=  SCP_ADR;
    Hal4Sys_SysCtrl_PORT  |=  SCP_SCL;
    outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT);
    Hal4Sys_SysCtrl_PORT  &= ~SCP_ADR;
    outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT);
}
void Hal4Sys_SPI_stop(void)
{
     Hal4Sys_SysCtrl_PORT  |=  SCP_ADR;

    outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT);
           CLK_SCL_L();
            MOSI_SDA_L(); 
}

void Hal4Sys_SPI_address(UCHAR data)
{

   UCHAR i,temp;
	   for(i=2; i<8; i++)
	   {
           temp = (data<<i)&0x80;
           if(temp)
            MOSI_SDA_H(); 
		   else
            MOSI_SDA_L(); 
           CLK_SCL_H();
           CLK_SCL_L();
	   }

}
void Hal4Sys_SPI_null(void)
{
   UCHAR i;
	   for(i=0; i<18; i++)
	   {
           CLK_SCL_H();
           CLK_SCL_L();
	   }

}
void Hal4Sys_SPI_senddata(UCHAR data)
{
   UCHAR i,temp;
	   for(i=0; i<8; i++)
	   {
           temp = (data<<i)&0x80;
           if(temp)
            MOSI_SDA_H(); 
		   else
            MOSI_SDA_L(); 
           CLK_SCL_H();
           CLK_SCL_L();
	   }
}

UCHAR Hal4Sys_SPI_getdata(void)
{
  UCHAR i,data,temp;
    data = 0;
	for(i=0; i<8; i++)
	{
       CLK_SCL_H();
       temp = ((~inportb(D09_INPUT_PORT))>>6)&0x01;
	   data =(data<<1)|temp;
       CLK_SCL_L();
	}
	return data;
}
void Hal4Sys_SetSPI_Mode(void)
{
    Hal4Sys_SysCtrl_PORT   |=  SCP_SPIEN;
    Hal4Sys_SysCtrl_PORT  |=  SCP_ADR;
    Hal4Sys_SysCtrl_PORT  |=  SCP_SCL;
    outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); 
    MOSI_SDA_L(); 
    Hal4Sys_ResetPCBA(); 
}

void Hal4Sys_SetI2C_Mode(void)
{
	if(bD09flags.bits.adr_state ==1)
	{
        Hal4Sys_SysCtrl_PORT  &= ~(SCP_SPIEN|SCP_SCL);
        Hal4Sys_SysCtrl_PORT  |=  SCP_ADR;
	}
	else
    	Hal4Sys_SysCtrl_PORT  &=~(SCP_ADR|SCP_SPIEN|SCP_SCL);
    outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); 
    MOSI_SDA_L(); 
    Hal4Sys_ResetPCBA(); 
}



void Hal4Sys_Service_Low(void)
{
    Hal4Sys_SysCtrl_PORT  |= SCP_SERVICE;
    outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); 
}

void Hal4Sys_Service_High(void)
{
    Hal4Sys_SysCtrl_PORT  &=  ~SCP_SERVICE;
    outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); 
}

void Hal4Sys_OE_High(void)
{
     Hal4Sys_SysCtrl_PORT  &= ~SCP_OEN;
    outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); 
}

void Hal4Sys_OE_Low(void)
{
    Hal4Sys_SysCtrl_PORT  |= SCP_OEN;
     outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); 
}


/*
UCHAR Hal4Sys_Get_Rxd(UCHAR TXD)
{
     UCHAR temp;
	 if(TXD)
      Hal4Sys_SysCtrl_PORT  |= SCP_TXD;
	 else
      Hal4Sys_SysCtrl_PORT  &= ~SCP_TXD; 

     outportb(D09_SYSCTRL_PORT,Hal4Sys_SysCtrl_PORT); 

     temp = inportb(D09_SYSCTRL_PORT); 

	 if(temp&0x04)
       return 1;
	 else
	   return 0;
}

UCHAR Hal4Sys_Get_Iset(void)
{
     UCHAR temp;
     temp = inportb(D09_SYSCTRL_PORT); 
	 if(temp&0x08)
       return 1;
	 else
	   return 0;
}*/

UCHAR Hal4Sys_Get_Int(void)
{
     UCHAR temp;
     temp = ~inportb(D09_INPUT_PORT); 
	 if(temp&0x80)
       return 1;
	 else
	   return 0;
}

void interrupt (*Hal4Sys_OldIsr4D09)(void);

void Hal4Sys_AcquireD09(void)
{
	UCHAR c, eo;

    Hal4Sys_OldIsr4D09 = getvect(0x0D);
	setvect(0x0D, usb_isr);
	c = inportb(0x21);
	c &= 0xDF;
	outportb(0x21, c);
    get_addresses();
}

void Hal4Sys_ReleaseD09(void)
{
	UCHAR c;
			outportb(D09_SYSCTRL_PORT,0); 
            outportb(D09_INOUT_PORT,0x01); 
	c = inportb(0x21);
	c |= 0x20;
	outportb(0x21, c);
	setvect(0xD, Hal4Sys_OldIsr4D09);

}