sidynamic.cpp

wince下SPI流驱动

// sidynamic.cpp : Defines the entry point for the DLL application.
//
#include <windows.h>

#include "stdafx.h"
#include "sidynamic.h"

volatile IOPreg * v_pIOPregs;
volatile SSPreg * v_pSSPregs;
HANDLE g_hInstance;

BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserve)
{
   switch(ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        g_hInstance = hModule;
//			RETAILMSG(1,(TEXT("PMSINGS: test=========ATTACH\n")));
			DisableThreadLibraryCalls((HMODULE) hModule);
        return TRUE;
    case DLL_THREAD_ATTACH:
//			RETAILMSG(1,(TEXT("PMSINGS: DLL_THREAD_ATTACH\n")));
        break;
    case DLL_THREAD_DETACH:
//		RETAILMSG(1,(TEXT("PMSINGS: DLL_THREAD_DETACH\n")));
        break;
    case DLL_PROCESS_DETACH:
//			RETAILMSG(1,(TEXT("PMSINGS: DLL_PROCESS_DETACH\n")));
        break;


   }
	
	return TRUE;
}
//---------------------------------------
//----stream function
//---------------------------------------


DWORD SPI_Init(DWORD dwContext)
{
//	RETAILMSG(1,(TEXT("PMSINGS: SPI_ INIT\n")));
    SPI_InitAddrIO();
    SPI_InitAddrSPI();
	InitSPI();
	
	return 0x01;
}

DWORD SPI_Close(DWORD Handle)
{
    return TRUE;
}   


//
// Device deinit - devices are expected to close down.
// The device manager does not check the return code.
DWORD SPI_Deinit(
    DWORD dwContext     // future: pointer to the per disk structure
    )
{
    return TRUE;
}   


//
// Returns handle value for the open instance.
DWORD SPI_Open(
    DWORD dwData,
    DWORD dwAccess,
    DWORD dwShareMode
    )
{
    return 1;
}   

DWORD SPI_IOControl(
    DWORD Handle,
    DWORD dwIoControlCode,
    PBYTE pInBuf,
    DWORD nInBufSize,
    PBYTE pOutBuf,
    DWORD nOutBufSize,
    PDWORD pBytesReturned
    )
{
    return FALSE;
}   


DWORD SPI_Read(DWORD Handle, char* pBuffer, DWORD dwNumBytes)
{
	
    while(! (v_pSSPregs->rSPSTA1&0x01) );
    v_pSSPregs->rSPRDAT1 = *pBuffer; // Write Potentiometer value
	return 1;
}


 DWORD SPI_Write(DWORD Handle, char* pBuffer, DWORD dwNumBytes)
{
	// Add SPI write to 


   // Set CS to low to activate 
   // v_pIOPregs->rGPGDAT &= ~(0x1 << 3);


   // Check the status of Transfer Ready flag(READY=1) ,and then write data to SPTDAT0
   // while( (v_pSSPregs->rSPSTA0 & 0x01) != 1 );
   //v_pSSPregs->rSPTDAT0 = 0x11; // Write MCP41010 write command 

   while(! (v_pSSPregs->rSPSTA1 & 0x01) );
   v_pSSPregs->rSPTDAT1 = *pBuffer; // Write Potentiometer value
  
   // Wait to complete write data
   //while( (v_pSSPregs->rSPSTA0 & 0x01) != 1 );
 
  
   // Set CS to high to deactivate MCP41010
   // v_pIOPregs->rGPGDAT |= (0x1 << 3);

	return 1;
}


 DWORD SPI_Seek(DWORD Handle, long lDistance, DWORD dwMoveMethod)
{
	return 0;
}

void SPI_PowerUp(void)
{
	return;
}

void SPI_PowerDown(void)
{ 
	return;
}




//--------------------------------------
//initilize function
//---------------------------------------



void InitSPI(void) //init uart2
{
	  unsigned int pclk = S2410PCLK;  // s2410.h define
      v_pIOPregs->rGPECON = ((v_pIOPregs->rGPECON &0xf03fffff)|0xa800000);
	  v_pIOPregs->rGPEUP &= ~(0x3800);	
	  v_pIOPregs->rGPEDAT|= 0x2000; 
                                  
	  v_pIOPregs->rGPGCON =((v_pIOPregs->rGPGCON &0xffffffcf)|0x10);                           
	  v_pIOPregs->rGPGUP &= ~(0x1 << 3);	
	  v_pIOPregs->rGPGDAT|= 0x4; 

      v_pSSPregs->rSPPRE1=0x0;	//if PCLK=50Mhz,SPICLK=25Mhz
      v_pSSPregs->rSPCON1=(0<<5)|(1<<4)|(1<<3)|(1<<2)|(0<<1)|(0<<0);//Polling,en-SCK,master,low,A,normal
      v_pSSPregs->rSPPIN1=(0<<2)|(1<<1)|(0<<0);//dis-ENMUL,SBO,release                   
	

}


BOOL SPI_InitAddrIO( void )
{
     BOOL RetValue = TRUE;

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



BOOL SPI_InitAddrSPI(void)
{
		BOOL	RetValue = TRUE;
//		RETAILMSG (1, (TEXT("SPI_InitializeAddresses \r\n") ));
        v_pSSPregs = (volatile SSPreg *)VirtualAlloc(0, sizeof(SSPreg), MEM_RESERVE, PAGE_NOACCESS);
		if (v_pSSPregs == NULL) 
		{
//			ERRORMSG(1,(TEXT("For SPI_UART2regs : VirtualAlloc failed!\r\n")));
			RetValue = FALSE;
		}
		else 
		{
			if (!VirtualCopy((PVOID)v_pSSPregs, (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 (v_pSSPregs) 
			{
				VirtualFree((PVOID) v_pSSPregs, 0, MEM_RELEASE);
			}
			v_pSSPregs = NULL;
		}
		else 
		{
			;
//			RETAILMSG (1, (TEXT("SPI_InitializeAddresses - Success\r\n") ));
		}
		return(RetValue);
}