📄 pxa-gspi.c

📁 自制PDA系列之SPI接口无线局域网卡驱动（处理器S3C2410(PXA270的版本本人还没改好
💻 C
📖 第 1 页 / 共 4 页
字号:
上一页 1 2 34
///		None
///	Return:
///		None
void ssp_init_hw(PSSP_HARDWARE_CONTEXT	pHC)
{
   int t;
//   char dummy = (char)0xff;

	PHYSICAL_ADDRESS	S2440_GPIO_Base = {S3C2440A_BASE_REG_PA_IOPORT};
	PHYSICAL_ADDRESS	S2440_SSP_Base = {S3C2440A_BASE_REG_PA_SPI};
	PHYSICAL_ADDRESS	S2440_CLKMGR_Base  = {S3C2440A_BASE_REG_PA_CLOCK_POWER};
        PHYSICAL_ADDRESS	S2440_DMA_Base = {S3C2440A_BASE_REG_PA_DMA};	
        PHYSICAL_ADDRESS	S2440_INT_Base = {S3C2440A_BASE_REG_PA_INTR};	

	pHC->pGPIORegs = (S3C2440A_IOPORT_REG*)MmMapIoSpace(S2440_GPIO_Base, sizeof(S3C2440A_IOPORT_REG), FALSE);
	if (!pHC->pGPIORegs) {
		GSPIMSG(ERRMSG, (TEXT("Error in allocating GPIO register\n")));
		goto funcFinal;
	}
	
	pHC->pSSPRegs = (S3C2440A_SPI_REG*)MmMapIoSpace(S2440_SSP_Base, sizeof(S3C2440A_SPI_REG), FALSE);
	if (!pHC->pSSPRegs) {
		GSPIMSG(ERRMSG, (TEXT("Error in allocating SSP register\n")));
		goto funcFinal;
	}

	pHC->pCLKRegs = (S3C2440A_CLKPWR_REG*)MmMapIoSpace(S2440_CLKMGR_Base, sizeof(S3C2440A_CLKPWR_REG), FALSE);
	if (!pHC->pCLKRegs) {
		GSPIMSG(ERRMSG, (TEXT("Error in allocating SSP register\n")));
		goto funcFinal;
	}
	
	pHC->pDMARegs = (S3C2440A_DMA_REG*)MmMapIoSpace(S2440_DMA_Base, sizeof(S3C2440A_DMA_REG), FALSE);
	if (!pHC->pDMARegs) {
		GSPIMSG(ERRMSG, (TEXT("Error in allocating DMA register\n")));
		goto funcFinal;
	}

	pHC->pIntRegs = (S3C2440A_INTR_REG*)MmMapIoSpace(S2440_INT_Base, sizeof(S3C2440A_INTR_REG), FALSE);
	if (!pHC->pIntRegs) {
		GSPIMSG(ERRMSG, (TEXT("Error in allocating INTR register\n")));
		goto funcFinal;
	}
	
///Setup SPI interface 

    pHC->pGPIORegs ->GPECON &= ~((0x3 << 22) | (0x3 << 24) | (0x3 << 26));   // Clear GPE11,12,13
    pHC->pGPIORegs ->GPECON  |= ((0x2 << 22) | (0x2 << 24) | (0x2 << 26)); 
	
    pHC->pGPIORegs ->GPGCON &= ~(0x3 << 4); // Clear GPG2
    pHC->pGPIORegs ->GPGCON |= (0x1 << 4);  

//nSS0: pull up function is disabled

//pHC->pGPIORegs ->GPGUP|=(0x1 << 2);

    
	NdisMSleep(10);

   pHC->pSSPRegs->SPPRE0 = 1;

#if (USE_DMA == 1)
// DMAl mode, CLK enable, master mode, active high clock, format A, normal mode
pHC->pIntRegs->INTMSK&= ~(0x1<<18);//DMA1 service available
pHC->pSSPRegs->SPCON0 = (0x2<<5)|(1<<4)|(1<<3)|(0<<2)|(0<<1)|(0<<0);
#else
// poll mode, CLK enable, master mode, active high clock, format A, normal mode
pHC->pSSPRegs->SPCON0 = (0<<5)|(1<<4)|(1<<3)|(0<<2)|(0<<1)|(0<<0);
#endif

pHC->pSSPRegs->SPPIN0= ((0<<2) |(1<<1) |(0<<0));

    for(t=0;t<20000; t++); // delay	  
    
     
pHC->pGPIORegs->GPGDAT &= ~(0x1 << 2);       //Set _SS signal to low (Slave Select)
    for(t=0; t < 10; t++)
    {
    
    	  putcToSoc(pHC,0xFF);
    
    }


pHC->pGPIORegs->GPGDAT |= (0x1 << 2);        //Set _SS signal to high (Slave Select)


	intr_init(pHC);
	dma_init(pHC);
	
	
        EnableEINT(pHC);

funcFinal:

	return;
}

DWORD pxa_gspi_register_isr(DWORD ssphc, void* Adapter, ISRFUNC isrFunc)
{
	DWORD					result = -1;
	PSSP_HARDWARE_CONTEXT	pHC = (PSSP_HARDWARE_CONTEXT)ssphc;

	if ((pHC == NULL) || (Adapter == NULL) || (isrFunc == NULL)) {
		goto funcFinal;
	}
	pHC->isrContext = (HANDLE) Adapter;
	pHC->isrFunc = isrFunc;
	result = 0;

funcFinal:
	return result;
}

///////////////////////////////////////////////////////////////////////////////
///	SSP_Init - the init entry point
/// Input: 
///		dwContext - the context for this init 
///	Output:
///	Return: instance context
///		- Returns a DWORD which will be passed to Open & Deinit or NULL if
///          unable to initialize the device
///////////////////////////////////////////////////////////////////////////////
DWORD pxa_gspi_Init(void)
{
	PSSP_HARDWARE_CONTEXT	pHC = NULL;
//	HKEY	hKeyDevice;
//	LPCTSTR	pszActiveKey;

	ENTERFUNC();
#if (USE_DMA == 1)
	GSPIMSG(1, (TEXT("GSPI8385-Using DMA mode\n")));
#else
	GSPIMSG(1, (TEXT("GSPI8385-Using CPU mode\n\n")));
#endif ///USE_DMA

	pHC = LocalAlloc(LPTR, sizeof(SSP_HARDWARE_CONTEXT));
	if (pHC == NULL) {
		GSPIMSG(ERRMSG, (TEXT("Allocate SSP_HARDWARE_CONTEXT FAILED")));
		goto funcFinal;
	}
	///Initialize the member of SSP_HARDWARE_CONTEXT
	InitializeCriticalSection(&(pHC->SSPCrit));

	///Load the setting
	///pszActiveKey = (LPCTSTR)dwContext;
	///hKeyDevice = OpenDeviceKey(pszActiveKey);
	///LoadRegistrySettings(hKeyDevice, pHC);
	///RegCloseKey(hKeyDevice);

	ssp_init_hw(pHC);

	if(!(pHC->waitqueue = CreateEvent( NULL, FALSE, FALSE,NULL))) {
        GSPIMSG(ERRMSG, (TEXT("Init CreateEvent FAILED")));
        goto funcFinal;
    }

	pHC->DriverShutdown = FALSE;
	///Testing....
	//{
	//set_GPIO_signal(pHC->pGPIORegs, SSP_SFRM,SIG_DOWN);
	//udelay(pHC->pOSTRegs, 10);
	//set_GPIO_signal(pHC->pGPIORegs, SSP_SFRM,SIG_UP);
	//}

	{
		WORD	regval;
//		DWORD	regval32;
		//int i;
		///Initialization => Setting 
		///			DelayMode = 1, by unit of CLK
		///			SBM = 0x02, 16bit address, 16bit data

//Sleep(15000);		
		regval = 0x06;
		ssp_write_register((DWORD)pHC, 0x70, &regval);
		//GSPIMSG(1, (TEXT("Reg(0x70)= 0x%02x\r\n"), regval));

	
		//Sleep(1000);
		regval = 0x0;
		ssp_read_register((DWORD)pHC, &regval, 0x70);
		GSPIMSG(1, (TEXT("Reg(0x70)=%04xh, exp: 0x0006\n"), regval));	
		
		
		
	}
#if 0
	{

		WORD	regval;
//		regval = 0x06;
//		ssp_write_register((DWORD)pHC, 0x70, &regval);
//		regval = 0x06;
//		ssp_write_register((DWORD)pHC, 0x70, &regval);
//		regval = 0x06;
//		ssp_write_register((DWORD)pHC, 0x70, &regval);
//		regval = 0x06;
//		ssp_write_register((DWORD)pHC, 0x70, &regval);
//		regval = 0x06;
//		ssp_write_register((DWORD)pHC, 0x70, &regval);
//		regval = 0x06;
//		ssp_write_register((DWORD)pHC, 0x70, &regval);
//		regval = 0x06;
//		ssp_write_register((DWORD)pHC, 0x70, &regval);
//		regval = 0x06;
//		ssp_write_register((DWORD)pHC, 0x70, &regval);
//		regval = 0x06;
//		ssp_write_register((DWORD)pHC, 0x70, &regval);
//		regval = 0x06;
//		ssp_write_register((DWORD)pHC, 0x70, &regval);




		///Set the dummy CLK = 0 or 0x10 ==> not work
		///regval = 0x00100010;
		///ssp_write_register((DWORD)pHC, 0x6c, &regval);
		
		///Reading register 0x00, expect 0x0013
		ssp_read_register((DWORD)pHC, 0x00, &regval);
		GSPIMSG(1, (TEXT("Reg(0)=%04xh, exp: 0x0013\n"), regval));
		///Reading register 0x02, expect 0x0004
		ssp_read_register((DWORD)pHC, 0x02, &regval);
		GSPIMSG(1, (TEXT("Reg(2)=%04xh, exp: 0x0004\n"), regval));


		regval = 0xabcd;
		ssp_write_register((DWORD)pHC, 0x38, &regval);
		ssp_read_register((DWORD)pHC, 0x38, &regval);
		GSPIMSG(1, (TEXT("Reg(38)=%xh\n"), regval));
		

		
		//ssp_read_register((DWORD)pHC, 0x10, &regval);
		//GSPIMSG(1, (TEXT("Reg(0x10)=%04xh\n"), regval));

		//ssp_read_register((DWORD)pHC, 0x14, &regval);
		//GSPIMSG(1, (TEXT("Reg(0x14)=%04xh\n"), regval));

		//ssp_read_register((DWORD)pHC, 0x1c, &regval);
		//GSPIMSG(1, (TEXT("Reg(0x1c)=%04xh\n"), regval));

		//ssp_read_register((DWORD)pHC, 0x20, &regval);
		//GSPIMSG(1, (TEXT("Reg(0x20)=%04xh\n"), regval));
		


		{
			int i;
			char aa[512];
			for (i=0 ; i<512 ; i++) {
				aa[i] = i;
			}
//			for (i=0 ; i<512/2 ; i++) {
//				ssp_write_register((DWORD)pHC, 0x24, (WORD*)(&aa[i*2]));
//			}
			ssp_write_data_direct((DWORD)pHC, (WORD*)aa, 0x24, 512/2);
			memset(aa, 0, 512);
//			for (i=0 ; i<512/2 ; i++) {
//				ssp_read_register((DWORD)pHC, 0x24, (WORD*)(&aa[i*2]));
//			}
			ssp_read_data_direct((DWORD)pHC, (WORD*)aa, 0x24, 512/2, MVL_DEF_DRP);

			{
			for (i=0 ; i<512 ; i++) {
				aa[i] = 511-i;
			}
			ssp_write_data_direct((DWORD)pHC, (WORD*)aa, 0x24, 512/2);
			memset(aa, 0, 512);
			ssp_read_data_direct((DWORD)pHC, (WORD*)aa, 0x24, 512/2, MVL_DEF_DRP);
			for (i=0 ; i<512 ; i++) {
				aa[i] = i;
			}
			ssp_write_data_direct((DWORD)pHC, (WORD*)aa, 0x24, 512/2);
			memset(aa, 0, 512);
			ssp_read_data_direct((DWORD)pHC, (WORD*)aa, 0x24, 512/2, MVL_DEF_DRP);
			for (i=0 ; i<512 ; i++) {
				aa[i] = 511-i;
			}
			ssp_write_data_direct((DWORD)pHC, (WORD*)aa, 0x24, 512/2);
			memset(aa, 0, 512);
			ssp_read_data_direct((DWORD)pHC, (WORD*)aa, 0x24, 512/2, MVL_DEF_DRP);
			for (i=0 ; i<512 ; i++) {
				aa[i] = i;
			}
			ssp_write_data_direct((DWORD)pHC, (WORD*)aa, 0x24, 512/2);
			memset(aa, 0, 512);
			ssp_read_data_direct((DWORD)pHC, (WORD*)aa, 0x24, 512/2, MVL_DEF_DRP);
			
			}





			for (i=0 ; i<64 ; i++) {
				aa[i] = i;
			}
//			for (i=0 ; i<64/2 ; i++) {
//				ssp_write_register((DWORD)pHC, 0x18, (WORD*)(&aa[i*2]));
//			}
			ssp_write_data_direct((DWORD)pHC, (WORD*)aa, 0x18, 64/2);
			memset(aa, 0, 512);
//			for (i=0 ; i<64/2 ; i++) {
//				ssp_read_register((DWORD)pHC, 0x18, (WORD*)(&aa[i*2]));
//			}
			ssp_read_data_direct((DWORD)pHC, (WORD*)aa, 0x18, 64/2, MVL_DEF_DRP);
			memset(aa, 0, 512);

		}
	}
#endif ///0
	{
	//	GSPIMSG(1,(TEXT("Start TimingTest")));
	//	{
	//	int		lp;
	//	for (lp=0 ; lp<MAX_WAITus ; lp++) {			///Trial period (1s)
	//		udelay(pHC->pOSTRegs, 1);
	//		///NdisMSleep(1);
	//	}
		///Add one more delay at the end. Otherwise, the firmware download will failed. 
		/// (Don't know why)
	//	udelay(pHC->pOSTRegs, 50);			///Trial value
		///NdisMSleep(5);
	//	GSPIMSG(1,(TEXT("End TimingTest")));
		}
	//}
	///Testing....
	
funcFinal:
	GSPIMSG(PROGFLOW, (TEXT("SSP: %s returning 0x%x\r\n"), TEXT(__FUNCTION__), pHC));
	
	return (DWORD)pHC;
}

///////////////////////////////////////////////////////////////////////////////
///	SSP_Deinit - the I/O control entry point
/// Input: 
///		hDC - the context returned from SSP_Init
///	Output:
///	Return: TRUE
/// Notes: not used
///////////////////////////////////////////////////////////////////////////////
BOOL pxa_gspi_Deinit(DWORD hDC)
{
	BOOL	result = TRUE;
	PSSP_HARDWARE_CONTEXT	pHC = (PSSP_HARDWARE_CONTEXT)hDC;
	int		i;

	ENTERFUNC();
	if (pHC == NULL) {
		GSPIMSG(ERRMSG, (TEXT("Allocate SSP_HARDWARE_CONTEXT FAILED")));
		result = FALSE;
		goto funcFinal;
	}
	pHC->DriverShutdown = TRUE;

	if (pHC->hIntrHandle == NULL) {
		SetEvent(pHC->hIntrHandle);
		pHC->hIntrHandle = NULL;
	}

	#if (USE_DMA == 1) && (USE_DMAIRQ == 1)
	if(NULL != pHC->hBusAcceHND) {
        CloseBusAccessHandle(pHC->hBusAcceHND);
        pHC->hBusAcceHND = NULL;
    }
	#endif /// (USE_DMA == 1) && (USE_DMAIRQ == 1)
	for (i=0 ; i<MAXDMA_PARAM ; i++) {
		clrInterrupt(&pHC->DMAIntrInfo[i]);
	}


/*	
	if (pHC->hDMAIntrHandle == NULL) {
		SetEvent(pHC->hDMAIntrHandle);
		pHC->hDMAIntrHandle = NULL;
	}

	if (pHC->hGIIsr) {
		FreeIntChainHandler(pHC->hGIIsr);
		pHC->hGIIsr = NULL;
	}

	///Clean up the handler
	if (pHC->hDMAIntrHandle) {
        CloseHandle(pHC->hDMAIntrHandle);
        pHC->hDMAIntrHandle = NULL;
    }

	if (pHC->hDMAIntrHandle) {
        CloseHandle(pHC->hDMAIntrHandle);
        pHC->hDMAIntrHandle = NULL;
    }*/


	///Delete the synchronization semphore
	
	if (pHC->waitqueue) {
        CloseHandle(pHC->waitqueue);
        pHC->waitqueue = NULL;
    }

	DeleteCriticalSection(&(pHC->SSPCrit));
	if (LocalFree(pHC)) {
		result = FALSE;
	}
funcFinal:
	GSPIMSG(PROGFLOW, (TEXT("Exit %s (%xh) \n"), TEXT(__FUNCTION__), result));
	
	return result;
}


void EnableEINT(PSSP_HARDWARE_CONTEXT pHC)
{
   pHC->pGPIORegs->EINTMASK &= ~(0x1 << 11);    // enable interrupt for EINT11 	
}



/*
////////////////////////////////////////////////////////////////////////
{
	PWORD	dat = (PWORD)data;
	WORD t1;
	// poll mode, CLK enable, master mode, active high clock, format A, normal mode
pHC->pSSPRegs->SPCON0 = (0<<5)|(1<<4)|(1<<3)|(0<<2)|(0<<1)|(0<<0);
pHC->pSSPRegs->SPPIN0= ((0<<2) |(1<<1) |(0<<0));

            for (i=0;i<nword;i++) 
        {	

//Begin to read data
           while((pHC->pSSPRegs->SPSTA0 & 0x1)==0);	// wait while busy
           pHC->pSSPRegs->SPTDAT0 = (UCHAR)(0xff);	                
           while((pHC->pSSPRegs->SPSTA0 & 0x1)==0);	// wait while busy
           temp=pHC->pSSPRegs->SPRDAT0;

          // RETAILMSG(1,(L"temp=(0x%X)  ", temp));

            udelay(10);

           temp=temp<<8;
           pHC->pSSPRegs->SPTDAT0 = (UCHAR)(0xff);	                
           while((pHC->pSSPRegs->SPSTA0 & 0x1)==0);	// wait while busy
           t1=pHC->pSSPRegs->SPRDAT0;
           temp=temp | t1;

            RETAILMSG(1,(L"t1=(0x%X)  ", t1));
            *dat=temp;
            RETAILMSG(1,(L"%02d READ Value=(0x%x)\r\n", i,*dat));
               
          dat ++;
			
	}
}
goto funcFinal;
///////////////////////////////////////////////////////////////////
*/
上一页 1 2 34
💿 文件大小 944 K
👤 上传用户 Tonic2009
📂 所属分类 Windows CE
🏷️ 相关标签

#S3C2410 #PDA #270 #SPI
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -