spidrv.cpp

2410/wince下应用程序例程brick,COMMApp,DAC,DCMotor,mediaplayer,spi,stepmotor,tictac

// spidrv.cpp : Defines the entry point for the DLL application.
//

//#include "stdafx.h"
#include "spidrv.h"
#include "s2410.h"

volatile DWORD g_dwWaitCounter=0;

#define WAIT(x)  {for(g_dwWaitCounter=0;g_dwWaitCounter<x;g_dwWaitCounter++);}



volatile EXIO_TEST *exio=NULL;
volatile PWMreg *g_pPWMreg=NULL;


BOOL DllEntry( HANDLE hinstDLL, 
							DWORD  dwReason, 
							LPVOID lpvReserved)
{	
	//RETAILMSG(1,(TEXT("SPIDRV.DLL: dllentry\r\n")));
	return TRUE;
}

void 
SPI_Init()
{
	
	RETAILMSG(1,(TEXT("SPIDRV.DLL: SPI INIT\r\n")));
	
	SPI_InitAddrIO();          //GPIO地址映射
	SPI_InitAddrSPI();        //SPI 寄存器地址映射
	/////////////////////时钟寄存器///////////////////
	RETAILMSG(1,(TEXT("SPIDRV.DLL:STARTSPICLOCK \r\n")));
	g_pCLKPWRreg = (volatile CLKPWRreg *)VirtualAlloc(0, sizeof(CLKPWRreg), MEM_RESERVE, PAGE_NOACCESS);
	if (!g_pCLKPWRreg)
	{
		RETAILMSG(1, (TEXT("SPIDRV.DLL: VirtualAlloc failed!\r\n")));
		return;
	}
	if (!VirtualCopy((PVOID)g_pCLKPWRreg, (PVOID)(0xB0C00000), sizeof(CLKPWRreg), PAGE_READWRITE | PAGE_NOCACHE))
	{
		RETAILMSG(1, (TEXT("SPIDRV.DLL: VirtualCopy failed!\r\n")));
		return;
	}


	exio=(EXIO_TEST *)VirtualAlloc(0,sizeof(EXIO_TEST),MEM_RESERVE, PAGE_NOACCESS);
	if(!exio)
	{
		RETAILMSG(1,(TEXT("SPIDRV.DLL: exio virualalloc failed\r\n")));
		return;
		
	}
	if(!VirtualCopy((PVOID)exio,(PVOID)(EXIO_BASE),sizeof(EXIO_TEST),PAGE_READWRITE | PAGE_NOCACHE ))
	{
		RETAILMSG(1,(TEXT("SPIDRV.DLL:virtualcopy failed! \r\n")));
		return;
	}
	
	
	exio=(EXIO_TEST *)((unsigned char *)exio+0x100);
	
	exio->a |= 0xFFFFFF0F;    //DISABLE MAX504



	//----- 2. Configure the GPIO pins for SPI mode -----
	//
	//		   nSPICS0  (chip select)		= GPG2
	//		   SPICLK0  (SPI clock)			= GPE13
	//		   SPIMOSIO (SPI output data)	= GPE12
	//  

	RETAILMSG(1,(TEXT("SPIDRV.DLL: SPI INIT REG\r\n")));
	g_pIOPregs->rGPHCON &= 0x3ffffc;//CLEAR_GPG2_MASK;
	g_pIOPregs->rGPHCON |= 0x000001;//ENABLE_GPG2_OUTPUT;
	g_pIOPregs->rGPHUP  &= 0xfffe;//ENABLE_GPG2_PULLUP;

	g_pIOPregs->rGPHDAT |=0X0001;     //DISABLE MCP2510;
	

	
	g_pIOPregs->rGPECON &= 0xf03fffff;
	g_pIOPregs->rGPECON |= (ENABLE_SPICLK0 | ENABLE_SPIMSIO);
	g_pIOPregs->rGPEUP  |=DISABLE_SPICLK_SPIMSIO_PULLUP;	// Disable pullup-resistor for SPICLK0 and SPIMOSIO 

	
	
	g_pSPIregs->rSPCON0 = (SPI_MODE_POLLING | SPI_SELECT_MASTER | SPI_CLOCK_ENABLE |\
							SPI_CLOCK_POLARITY_HIGH |SPI_CLOCK_PHASE_FORMAT_A);

	SetSPIClockRate(CLK_RATE_EIGHT);

	g_pSPIregs->rSPPIN0=2;
	
	
	
	
	return;
}






BOOL SPI_SendByte(BYTE bData)
{
	
	StartSPIClock();
	g_pSPIregs->rSPTDAT0 = bData;

	while(!(g_pSPIregs->rSPSTA0 & SPI_TRANSFER_READY))
	
	RETAILMSG(1,(TEXT("SPIDRV.DLL:BYTE value is %x\r\n"),(unsigned int)bData));
	StopSPIClock();
	return 1;

}




BYTE SPI_RcvByte()
{
	
	
	return g_pSPIregs->rSPRDAT0;

}






void StartSPIClock(void)
{
	
	

	RETAILMSG(1,(TEXT("INITADDCLKPWREG SUCCESS\r\n")));
	g_pCLKPWRreg->rCLKCON |= 0x40000;//SPI_INTERNAL_CLOCK_ENABLE;
	g_pSPIregs ->rSPCON0  |= SPI_CLOCK_ENABLE;
	
	return;
}


void StopSPIClock(void)
{
	g_pCLKPWRreg->rCLKCON &= ~SPI_INTERNAL_CLOCK_ENABLE;
	g_pSPIregs ->rSPCON0 &= ~SPI_CLOCK_ENABLE;
	return;
}

VOID SetSPIClockRate(DWORD ClockRate)
{
	UINT16 prescale;

    //----- 1. Set the clock rate  -----
	//		   NOTE: Using the prescale value, the clock's baud rate is
	//				 determined as follows: baud_rate = (PCLK / 2 / (prescale + 1))
	//
	//				 Hence, the prescale value can be computed as follows:
	//				 prescale = ((PCLK / 2) / baud_rate) - 1
	switch(ClockRate)
	{
		case CLK_RATE_FULL:						// 25 Mhz			
		prescale = (S2410PCLK / 40000000) - 1;
		break;

		case CLK_RATE_HALF:						// 1/2  25 Mhz						
		prescale = (S2410PCLK / 30000000) - 1;
		break;

		case CLK_RATE_FOUR:						// 1/4  25 Mhz						
		prescale = (S2410PCLK / 10000000) - 1;
		break;

		case CLK_RATE_EIGHT:					// 1/8  25 Mhz						
		prescale = (S2410PCLK /  500000) - 1;
		break;

		case CLK_RATE_SIXTEEN:					// 1/16 25 Mhz						
		prescale = (S2410PCLK /  2500000) - 1;
		break;

		case CLK_RATE_THIRTY2:					// 1/32 25 Mhz						
		prescale = (S2410PCLK /  1250000) - 1;
		break;

		case CLK_RATE_SIXTY4:					// 1/64 25 Mhz						
		prescale = (S2410PCLK /   625000) - 1;
		break;

		case CLK_RATE_SLOW:						// 99.121 kHz (i.e. ~1/256 25Mhz)
		prescale = 40;
		break;

		default:
		RETAILMSG(1, (TEXT("WAVEDEV.DLL:setSPIClockRate() - Invalid clock rate specified!\r\n")));  
		return;
		break;
	}

	g_pSPIregs->rSPPRE0 = prescale;

		RETAILMSG(1,(TEXT("SETSPICLOCK VALUE IS %d"),g_pSPIregs->rSPPRE0));
    return;
}


BOOL
SPI_InitAddrIO(VOID)
{
		BOOL	RetValue = TRUE;
		RETAILMSG(1,(TEXT("SPIDRV.DLL: InitAddIO\r\n")));
		
	
		g_pIOPregs = (volatile IOPreg *)VirtualAlloc(0, sizeof(IOPreg), MEM_RESERVE, PAGE_NOACCESS);

		if (g_pIOPregs == NULL) 
		{
				
			RETAILMSG(1,(TEXT("For SPI_IOPregs : VirtualAlloc failed!\r\n")));
			RetValue = FALSE;
		}
		else 
		{
			if (!VirtualCopy((PVOID)g_pIOPregs, (PVOID)(IOP_BASE), sizeof(IOPreg), PAGE_READWRITE | PAGE_NOCACHE)) 
			{
				RETAILMSG(1,(TEXT("For SPI_IOPregs: VirtualCopy failed!\r\n")));
				RetValue = FALSE;
			}
		}
	
		if (!RetValue) 
		{
			RETAILMSG (1, (TEXT("::: SPI_InitializeAddresses - Fail!!\r\n") ));
			if (g_pIOPregs) 
			{
				VirtualFree((PVOID) g_pIOPregs, 0, MEM_RELEASE);
			}
			g_pIOPregs = NULL;
		}
		else 
		{
			
			RETAILMSG (1, (TEXT("::: SPI_InitializeAddIO- Success\r\n") ));
		}

		return(RetValue);
}





BOOL SPI_InitAddrSPI(void)
{
		BOOL	RetValue = TRUE;

		RETAILMSG (1, (TEXT("SPI_InitializeAddSPI \r\n") ));

		g_pSPIregs = (volatile SSPreg *)VirtualAlloc(0, sizeof(SSPreg), MEM_RESERVE, PAGE_NOACCESS);
		if (g_pSPIregs == NULL) 
		{
			ERRORMSG(1,(TEXT("For SPI_UART2regs : VirtualAlloc failed!\r\n")));
			RetValue = FALSE;
		}
		else 
		{
			if (!VirtualCopy((PVOID)g_pSPIregs, (PVOID)(SSP_BASE), sizeof(SSPreg), PAGE_READWRITE | PAGE_NOCACHE)) 
			{
				ERRORMSG(1,(TEXT("For SPI_UART2regs: VirtualCopy failed!\r\n")));
				RetValue = FALSE;
			}
		}
	
		if (!RetValue) 
		{
			RETAILMSG (1, (TEXT("::: SPI_InitializeAddresses - Fail!!\r\n") ));
			if (g_pSPIregs) 
			{
				VirtualFree((PVOID) g_pSPIregs, 0, MEM_RELEASE);
			}
			g_pSPIregs = NULL;
		}
		else 
		{
			
			RETAILMSG (1, (TEXT("SPI_InitializeAddSPI- Success\r\n") ));
		}
		return(RetValue);
}