⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 pxa-gspi.c

📁 此压缩包为杰得开发得z228的BSP的源代码,可以实现很多功能,尤其是视频解码有很好的效果.
💻 C
📖 第 1 页 / 共 4 页
字号:
🔍
1234 
/// Input: 
///		pHC - Hard context
///	Output:
///		None
///	Return:
///		None
void ssp_init_hw(PSSP_HARDWARE_CONTEXT	pHC)
{
/*
	PHYSICAL_ADDRESS	Bulverde_GPIO_Base = {BULVERDE_BASE_REG_PA_GPIO};
	PHYSICAL_ADDRESS	Bulverde_SSP_Base = {SSPREG_PHY_BASE};
	PHYSICAL_ADDRESS	Bulverde_CLKMGR_Base = {BULVERDE_BASE_REG_PA_CLKMGR};
	PHYSICAL_ADDRESS	Bulverde_DMA_Base = {BULVERDE_BASE_REG_PA_DMAC};
	PHYSICAL_ADDRESS	Bulverde_PA_OTS_Base = {BULVERDE_BASE_REG_PA_OST};
	PHYSICAL_ADDRESS	Bulverde_ICR_Base = {BULVERDE_BASE_REG_PA_INTC};
*/
	PHYSICAL_ADDRESS PhysicalAddress;
	//unsigned long pa;
	
	RETAILMSG(1, (TEXT("ssp_init_hw() 070703 new_dev_second\r\n")));

	PhysicalAddress.HighPart = 0;	
	//PhysicalAddress.LowPart = 0x2002C000;//GPIO5_BASE;		
	PhysicalAddress.LowPart = GpioBaseAddr[WIFI_CS_num];	//wifi CS;		
	pHC->pGPIORegs_CS= (PGPIO_REGS)MmMapIoSpace(PhysicalAddress, sizeof(GPIO_REGS), FALSE);
	if (!pHC->pGPIORegs_CS) {
		RETAILMSG(1, (TEXT("Error in allocating CS GPIO register\n")));
		goto funcFinal;
	}

	if(WIFI_INT_num == WIFI_CS_num)
	{
		pHC->pGPIORegs_INT = pHC->pGPIORegs_CS;
	}
	else
	{
		PhysicalAddress.HighPart = 0;	
		PhysicalAddress.LowPart = GpioBaseAddr[WIFI_INT_num];	//wifi INT;	
		pHC->pGPIORegs_INT= (PGPIO_REGS)MmMapIoSpace(PhysicalAddress, sizeof(GPIO_REGS), FALSE);
		if (!pHC->pGPIORegs_INT)
		{
			RETAILMSG(1, (TEXT("Error in allocating INT GPIO register\n")));
			goto funcFinal;
		}
	}
	
	PhysicalAddress.HighPart = 0;
	PhysicalAddress.LowPart = 0x20034000;//SSP_BASE;		
	pHC->pSSPRegs = (PSSP_REGS)MmMapIoSpace(PhysicalAddress, sizeof(SSP_REGS), FALSE);
	if (!pHC->pSSPRegs) {
		RETAILMSG(1, (TEXT("Error in allocating SSP register\n")));
		goto funcFinal;
	}

	RETAILMSG(1, (TEXT("ssp_init_hw::pHC->pGPIORegs_INT = 0x%x, pHC->pGPIORegs_CS = 0x%x\r\n"), pHC->pGPIORegs_INT, pHC->pGPIORegs_CS));
	
	NdisMSleep(10);

	// Configure the CS signal high to disable wifi
	pHC->pGPIORegs_CS->GPIODir |= (1<<WIFI_CS_pin); 
	pHC->pGPIORegs_CS->Padding1[254]  |= (1<<WIFI_CS_pin); 
		
	// Configure the SSP
	//pHC->pSSPRegs->SSPCR0 = 0x0F07;	// SCR[7:0] = f, moto mode, SPI 0,0 , 8-bits/ts
	pHC->pSSPRegs->SSPCR0 = 0x000F;	// SCR[7:0] = f, moto mode, SPI 0,0 , 16-bits/ts
	//pHC->pSSPRegs->SSPCR0 = 0x020F;	// SCR[7:0] = f, moto mode, SPI 0,0 , 16-bits/ts
	pHC->pSSPRegs->SSPIMSC = 0x0000;	// interrupt is mask
	//pHC->pSSPRegs->SSPCPSR = 0x0004;	//0x0002;	// pre-scale : CPSDVSR=20
	pHC->pSSPRegs->SSPCPSR = 0x0002;	//0x0002;	// pre-scale : CPSDVSR=20
	pHC->pSSPRegs->SSPDMACR = 0x0000;	// disable Tx&Rx DMA
	//pHC->pSSPRegs->SSPCR1 = 0x0000;	// disable SSP	
	pHC->pSSPRegs->SSPCR1 = 0x0002;	// enable SSP	

/*
	//pHC->iodata = (PBYTE) HalAllocateCommonBuffer(&Adapter, PXA_SSP_IODATA_SIZE, &PA, FALSE);
	pHC->iodata = (PBYTE)AllocPhysMem(PXA_SSP_IODATA_SIZE, PAGE_READWRITE, 0, 0, &pa);
	if (pHC->iodata) 
	{
		pHC->phys_addr = (PBYTE)pa;
    	}
*/
	intr_init(pHC);
	RETAILMSG(1, (TEXT("intr_init() End !\r\n")));
	dma_init(pHC);

funcFinal:
	return;
}


DWORD pxa_gspi_register_isr(DWORD ssphc, void* Adapter, ISRFUNC isrFunc)
{
	PSSP_HARDWARE_CONTEXT	pHC = (PSSP_HARDWARE_CONTEXT)ssphc;
	DWORD					result = -1;
	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;
	int i=0;
//	HKEY	hKeyDevice;
//	LPCTSTR	pszActiveKey;

	//yz_add
	HANDLE wifi_share_event;
	wifi_share_event = CreateEvent(NULL, FALSE, FALSE, _T("wifi"));	
	if(wifi_share_event == NULL)
	{
        RETAILMSG(1, (TEXT("wifi_share_event Create Error\r\n")));		
		return 0;
	}
	
	ENTERFUNC();
#if (USE_DMA == 1)
	GSPIMSG(1, (TEXT("GSPI - Using DMA mode\n")));
#else
	GSPIMSG(1, (TEXT("GSPI - Using CPU mode 1.0\r\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);

	//yz_add for low power-consume
	//WaitForSingleObject(wifi_share_event, INFINITE);
	GSPIMSG(1, (TEXT("WIFI Event come!\r\n")));
	
	ssp_init_hw(pHC);
	GSPIMSG(1, (TEXT("ssp_init_hw() End\r\n")));
	
	if(!(pHC->waitqueue = CreateEvent( NULL, FALSE, FALSE,NULL))) {
        GSPIMSG(ERRMSG, (TEXT("Init CreateEvent FAILED")));
        goto funcFinal;
    }

	///crlo:verion-check ++
	///GSPI8385: (0004, 0013)
	///GSPI8686: (000b, 0010)
	{
		WORD	regval;
#if defined (GSPI8385)
		const WORD	chipid = 0x0004;
#elif defined (GSPI8686)
		const WORD	chipid = 0x000b;
#else
		const WORD	chipid = 0x000;
#endif ///GSPI$(CHIPID)
		///ssp_read_register((DWORD)pHC, &regval, 0x00);
		///GSPIMSG(1, (TEXT("Reg(0x00)= 0x%04x\r\n"), regval));
		
		//yz_add for test
		ssp_read_register((DWORD)pHC, &regval, 0x00);
		GSPIMSG(1, (TEXT("Reg(0x00)= 0x%04x\r\n"), regval));
		
		//while(1)
		//yz_end	
		ssp_read_register((DWORD)pHC, &regval, 0x02);		
		GSPIMSG(1, (TEXT("Reg(0x02)= 0x%04x\r\n"), regval));

		///================================================
		if (chipid != regval){
			GSPIMSG(1, (TEXT("Chip(exp, val)= (%04xh), %04xh)\n"), chipid, regval));
			pxa_gspi_Deinit((DWORD)pHC);
			pHC = NULL;
			goto funcFinal;
		}
	}
	///crlo:verion-check --

	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);
	}*/
#if 0	
	for(i = 0; i<1; i++)
	{
		WORD	regval;

		///Initialization => Setting 
		///			DelayMode = 1, by unit of CLK
		///			SBM = 0x02, 16bit address, 16bit data
		regval = 0x06;
		ssp_write_register((DWORD)pHC, 0x70, &regval);
		regval = 0x0;
		ssp_read_register((DWORD)pHC, &regval, 0x70);
		GSPIMSG(1, (TEXT("Reg(0x70)= 0x%02x\r\n"), regval));
	}
#endif	
	
#if 0
	{
		WORD	regval;

		///Initialization => Setting 
		///			DelayMode = 1, by unit of CLK
		///			SBM = 0x02, 16bit address, 16bit data
		regval = 0x06;
		ssp_write_register((DWORD)pHC, 0x70, &regval);
		regval = 0x0;
		ssp_read_register((DWORD)pHC, &regval, 0x70);
		GSPIMSG(1, (TEXT("Reg(0x70)= 0x%02x\r\n"), regval));
	}
	{
		int i;
		unsigned char aa[512];

		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/16 ; i++) {
			GSPIMSG(1, (TEXT("%02x %02x %02x %02x %02x %02x %02x %02x - %02x %02x %02x %02x %02x %02x %02x %02x \n"), 
				aa[i*16+0], aa[i*16+1], aa[i*16+2], aa[i*16+3], 
				aa[i*16+4], aa[i*16+5], aa[i*16+6], aa[i*16+7], 
				aa[i*16+8], aa[i*16+9], aa[i*16+10], aa[i*16+11], 
				aa[i*16+12], aa[i*16+13], aa[i*16+14], aa[i*16+15]));
		}

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

		for (i=0 ; i<64/16 ; i++) {
			GSPIMSG(1, (TEXT("%02x %02x %02x %02x %02x %02x %02x %02x - %02x %02x %02x %02x %02x %02x %02x %02x \n"), 
				aa[i*16+0], aa[i*16+1], aa[i*16+2], aa[i*16+3], 
				aa[i*16+4], aa[i*16+5], aa[i*16+6], aa[i*16+7], 
				aa[i*16+8], aa[i*16+9], aa[i*16+10], aa[i*16+11], 
				aa[i*16+12], aa[i*16+13], aa[i*16+14], aa[i*16+15]));
		}
	}

	{

		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)
	//yz_mask
	//for (i=0 ; i<MAXDMA_PARAM ; i++) {
		//clrInterrupt(&pHC->DMAIntrInfo[i]);
	//}
	//yz_mask_end


/*	
	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;
}
1234

⌨️ 快捷键说明

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