📄 pxa-gspi.c

📁 非常好的marvall 8686驱动源码
💻 C
📖 第 1 页 / 共 4 页
字号:
上一页 1 2 34

	pHC->pGPIORegs = (BULVERDE_GPIO_REG*)MmMapIoSpace(Bulverde_GPIO_Base, sizeof(BULVERDE_GPIO_REG), FALSE);
	if (!pHC->pGPIORegs) {
		GSPIMSG(ERRMSG, (TEXT("Error in allocating GPIO register\n")));
		goto funcFinal;
	}
	
	pHC->pSSPRegs = (BULVERDE_SSP_EXT_REG*)MmMapIoSpace(Bulverde_SSP_Base, sizeof(BULVERDE_SSP_EXT_REG), FALSE);
	if (!pHC->pSSPRegs) {
		GSPIMSG(ERRMSG, (TEXT("Error in allocating SSP register\n")));
		goto funcFinal;
	}
	
	pHC->pCLKRegs = (BULVERDE_CLKMGR_REG*)MmMapIoSpace(Bulverde_CLKMGR_Base, sizeof(BULVERDE_CLKMGR_REG), FALSE);
	if (!pHC->pCLKRegs) {
		GSPIMSG(ERRMSG, (TEXT("Error in allocating CLK register\n")));
		goto funcFinal;
	}

	pHC->pDMARegs = (BULVERDE_DMA_REG*)MmMapIoSpace(Bulverde_DMA_Base, sizeof(BULVERDE_DMA_REG), FALSE);
	if (!pHC->pDMARegs) {
		GSPIMSG(ERRMSG, (TEXT("Error in allocating DMA register\n")));
		goto funcFinal;
	}

	pHC->pOSTRegs = (BULVERDE_OST_REG*)MmMapIoSpace(Bulverde_PA_OTS_Base, sizeof(BULVERDE_OST_REG), FALSE);
	if (!pHC->pOSTRegs) {
		GSPIMSG(ERRMSG, (TEXT("Error in allocating OST register\n")));
		goto funcFinal;
	}

	///
	///Configure the GPIO 
	///
	set_GPIO_mode(pHC->pGPIORegs, SSP_SCLK|SSPSCLK_ATTR);				///SCLK
	set_GPIO_mode(pHC->pGPIORegs, SSP_SFRM|SSPSFRM_ATTR);				///SFRM
	set_GPIO_mode(pHC->pGPIORegs, SSP_TX|SSPTX_ATTR);					///TX
	set_GPIO_mode(pHC->pGPIORegs, SSP_RX|SSPRX_ATTR);					///RX
	set_GPIO_signal(pHC->pGPIORegs, SSP_SFRM, SIG_UP); 
     
     
	pHC->pSSPRegs->base.sscr0 = 0;
	pHC->pSSPRegs->base.sscr1 = 0;

	///udelay(pHC->pOSTRegs, 100);
	NdisMSleep(10);
	///
	/// Configure the SSP CLK
	///
#if (SSPCTRLER == 1)					///Using SSP controller1
	pHC->pCLKRegs->cken |= (1<<23);
#elif (SSPCTRLER == 2)					///Using SSP controller2
	pHC->pCLKRegs->cken |= (1<<3);
#elif (SSPCTRLER == 3)					///Using SSP controller3
	pHC->pCLKRegs->cken |= (1<<4);
#endif ///SSPCTRLER

	pHC->pSSPRegs->base.sscr0 = SSCR0_SCR(clkdiv) | SSCR0_DSS(0x000f) | SSCR0_FRF(3);
	pHC->pSSPRegs->base.sscr1 = SSCR1_TTELP | SSCR1_TTE | SSCR1_TSRE | SSCR1_RSRE |
			SSCR1_RFT(0x1) | SSCR1_TFT(0x1) | SSCR1_TRAIL;


	pHC->pSSPRegs->sspsp = SSPSP_SCMODE(0);
	pHC->pSSPRegs->ssto = 1;
	pHC->pSSPRegs->base.sscr0 |= SSCR0_SSE;

	intr_init(pHC);
	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;
//	HKEY	hKeyDevice;
//	LPCTSTR	pszActiveKey;

	ENTERFUNC();
#if (USE_DMA == 1)
	GSPIMSG(1, (TEXT("GSPI - Using DMA mode\n")));
#else
	GSPIMSG(1, (TEXT("GSPI - 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;
    }

	///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));
		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
	{
		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)
	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;
}
上一页 1 2 34
💿 文件大小 1075 K
👤 上传用户 jxsflq
📂 所属分类驱动编程
🏷️ 相关标签

#marvall #8686 #驱动 #源码
⌨️ 快捷键说明

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