pspandrv.c

powerspan pci slave device driver

    
    
    		
    DWORD dwVendorID = pciScan->searchId.dwVendorId;
    DWORD dwDeviceID = pciScan->searchId.dwDeviceId;

    pciScan->dwCards = 0;
    
    for(li = 0; li<32;li++)
    {
        	if( pciFindDevice(dwVendorID,dwDeviceID,li,&pBusNo,&pDeviceNo,&pFuncNo)==0)
	    	{
	    		pciScan->dwCards++;
	    	
	    		pciScan->cardSlot[li].dwBus = pBusNo;
	    		pciScan->cardSlot[li].dwSlot = pDeviceNo;
	    		pciScan->cardSlot[li].dwFunction = pFuncNo;
	    	
        	//pspandrv_printf("\nfind device %d ok\n",li); 
            }
            else
            {
             	break;
            }
    }// end of for loop
    
}// end of PciScanCards_pspan


/*******************************************************************************
* 	get the Version_pspan
*/
LOCAL void Version_pspan(WD_VERSION *ver)
{
	ver->dwVer = WD_VER;
	
}


/*******************************************************************************
* 	get the Pci Card Information
*/
LOCAL void PciGetCardInfo_pspan (WD_PCI_CARD_INFO *pciCardInfo)
{	
	// null
	DWORD dwBus = pciCardInfo->pciSlot.dwBus;
	DWORD dwSlot = pciCardInfo->pciSlot.dwSlot;
	DWORD dwFunction = pciCardInfo->pciSlot.dwFunction;
	return;	
}


/*******************************************************************************
* 	reginster the card
*/
LOCAL void CardRegister_pspan(PSPAN_STRUCT_MY *hPlx)
{
	int   pBusNo;
    	int   pDeviceNo;
    	int   pFuncNo;
    	
    	DWORD la;
    	DWORD lb;
	
	hPlx->cardReg.hCard = 1;
	
	pBusNo = hPlx->pciSlot.dwBus;
	pDeviceNo = hPlx->pciSlot.dwSlot;
	pFuncNo = hPlx->pciSlot.dwFunction;
	
	pciConfigInLong(pBusNo,pDeviceNo,pFuncNo,0x10,&la);
        pciConfigInAddressSpace(pBusNo,pDeviceNo,pFuncNo,0x10,&lb);
    	hPlx->addrDesc[0].dwLocalBase = 0;
    	hPlx->addrDesc[0].dwBytes = ( ~( lb & 0xfffffff0 ) + 1 );
    	hPlx->addrDesc[0].dwAddr = (la & 0xfffffff0 );
   	hPlx->addrDesc[0].dwAddrDirect = (la & 0xfffffff0 );
   	hPlx->addrDesc[0].fIsMemory = 1;
   	hPlx->addrDesc[0].dwMask =  ~( lb & 0xfffffff0 );        
        
                    
        pciConfigInLong(pBusNo,pDeviceNo,pFuncNo,0x14,&la);
        pciConfigInAddressSpace(pBusNo,pDeviceNo,pFuncNo,0x14,&lb);
    	hPlx->addrDesc[1].dwLocalBase = 0;
    	hPlx->addrDesc[1].dwBytes = ( ~( lb & 0xfffffff0 ) + 1 );
    	hPlx->addrDesc[1].dwAddr = (la & 0xfffffff0 );
   	hPlx->addrDesc[1].dwAddrDirect = (la & 0xfffffff0 );
   	hPlx->addrDesc[1].fIsMemory = 1;
   	hPlx->addrDesc[1].dwMask =  ~( lb & 0xfffffff0 );                
        
        
        pciConfigInLong(pBusNo,pDeviceNo,pFuncNo,0x18,&la);
        pciConfigInAddressSpace(pBusNo,pDeviceNo,pFuncNo,0x18,&lb);
    	hPlx->addrDesc[2].dwLocalBase = 0;
    	hPlx->addrDesc[2].dwBytes = ( ~( lb & 0xfffffff0 ) + 1 );
    	hPlx->addrDesc[2].dwAddr = (la & 0xfffffff0 );
   	hPlx->addrDesc[2].dwAddrDirect = (la & 0xfffffff0 );
   	hPlx->addrDesc[2].fIsMemory = 1;
   	hPlx->addrDesc[2].dwMask =  ~( lb & 0xfffffff0 );    
   	
        pciConfigInLong(pBusNo,pDeviceNo,pFuncNo,0x1c,&la);
        pciConfigInAddressSpace(pBusNo,pDeviceNo,pFuncNo,0x1c,&lb);
    	hPlx->addrDesc[3].dwLocalBase = 0;
    	hPlx->addrDesc[3].dwBytes = ( ~( lb & 0xfffffff0 ) + 1 );
    	hPlx->addrDesc[3].dwAddr = (la & 0xfffffff0 );
   	hPlx->addrDesc[3].dwAddrDirect = (la & 0xfffffff0 );
   	hPlx->addrDesc[3].fIsMemory = 1;
   	hPlx->addrDesc[3].dwMask =  ~( lb & 0xfffffff0 );       	
   	
}


/*******************************************************************************
* 	unresgister the card
*/

LOCAL void CardUnregister_pspan(PSPAN_STRUCT_MY *hPlx)
{
	hPlx->cardReg.hCard = 0;
	
}


/*******************************************************************************
* 	Pci  Config  Dump
*/

LOCAL void PciConfigDump_pspan(WD_PCI_CONFIG_DUMP *pciCnf)
{
    int li;
    
    for(li=0;li<pciCnf->dwBytes;li++)
    {
   	
    	if( pciCnf->fIsRead )
    	{
    		pciConfigInByte(pciCnf->pciSlot.dwBus,pciCnf->pciSlot.dwSlot,pciCnf->pciSlot.dwFunction,\
    				pciCnf->dwOffset,pciCnf->pBuffer);
    	}
    	else
    	{
		pciConfigOutByte(pciCnf->pciSlot.dwBus,pciCnf->pciSlot.dwSlot,pciCnf->pciSlot.dwFunction,\
    				pciCnf->dwOffset,*((BYTE *)pciCnf->pBuffer) );    		
    	}
    	
    	pciCnf->pBuffer++;
    	pciCnf->dwOffset++;
    	
    } // end of for loop
	
}//end of PciConfigDump_pspan


/*******************************************************************************
* 	Sleep_pspan 
*/
LOCAL void Sleep_pspan( WD_SLEEP *pParam )
{
	taskDelay( 0.1 );
}



/*******************************************************************************
* 	Transfer_pspan 
*/

LOCAL void Transfer_pspan(WD_TRANSFER *trans)
{
	int li;
	
	switch(trans->cmdTrans)
	{
		///////////////////////////////////////////////////////////////
		case	RP_BYTE:
			trans->Data.Byte = sysInByte( (BYTE *)trans->dwPort );
			break;
		
		case	RP_WORD:
			trans->Data.Word = sysInWord( (WORD *)trans->dwPort );
			break;

		case	RP_DWORD:
			trans->Data.Dword = sysInLong( (DWORD *)trans->dwPort );
			break;
		/////////////////
		case	WP_BYTE:
			sysOutByte(trans->dwPort,trans->Data.Byte);
			break;
		
		case	WP_WORD:
			sysOutWord(trans->dwPort,trans->Data.Word);
			break;

		case	WP_DWORD:
			sysOutLong(trans->dwPort,trans->Data.Dword);
			break;	
		
		
		////////////////////////////////////////////////////////////////
		case	RM_SBYTE:
			trans->dwBytes *= 1;
			for( li = 0; li < trans->dwBytes; li++)
			{
				*( (BYTE *)(trans->Data.pBuffer) ) = *( (BYTE *)trans->dwPort );
				(BYTE *)trans->Data.pBuffer++;
				(BYTE *)trans->dwPort++;
			}
			break;
			
		case	RM_SWORD:
			trans->dwBytes *= 1;
			for( li = 0; li < trans->dwBytes; li++)
			{
				*( (BYTE *)(trans->Data.pBuffer) ) = *( (BYTE *)trans->dwPort );
				(BYTE *)trans->Data.pBuffer++;
				(BYTE *)trans->dwPort++;
			}
			break;
			
		case	RM_SDWORD:
			trans->dwBytes *= 1;
			for( li = 0; li < trans->dwBytes; li++)
			{
				*( (BYTE *)(trans->Data.pBuffer) ) = *( (BYTE *)trans->dwPort );
				(BYTE *)trans->Data.pBuffer++;
				(BYTE *)trans->dwPort++;
			}
			break;
		
		/////////////////////////
		case	WM_SBYTE:
			trans->dwBytes *= 1;
			for( li = 0; li < trans->dwBytes; li++)
			{
				*( (BYTE *)trans->dwPort ) = *( (BYTE *)(trans->Data.pBuffer) );
				(BYTE *)trans->Data.pBuffer++;
				(BYTE *)trans->dwPort++;
			}
			break;
			
		case	WM_SWORD:
			trans->dwBytes *= 1;
			for( li = 0; li < trans->dwBytes; li++)
			{
				*( (BYTE *)trans->dwPort ) = *( (BYTE *)(trans->Data.pBuffer) );
				(BYTE *)trans->Data.pBuffer++;
				(BYTE *)trans->dwPort++;
			}
			break;
			
		case	WM_SDWORD:
			trans->dwBytes *= 1;
			for( li = 0; li < trans->dwBytes; li++)
			{
				*( (BYTE *)trans->dwPort ) = *( (BYTE *)(trans->Data.pBuffer) );
				(BYTE *)trans->Data.pBuffer++;
				(BYTE *)trans->dwPort++;
			}
			break;


		//////////////////////////////////////////////////////////////////////////
		case	RP_SBYTE:
			trans->dwBytes *= 1;
			for( li = 0; li < trans->dwBytes; li++)
			{
				*( (BYTE *)(trans->Data.pBuffer) ) = sysInByte( (BYTE *)trans->dwPort );
				(BYTE *)trans->Data.pBuffer++;
				(BYTE *)trans->dwPort++;
			}
			break;
			
		case	RP_SWORD:
			trans->dwBytes *= 1;
			for( li = 0; li < trans->dwBytes; li++)
			{
				*( (BYTE *)(trans->Data.pBuffer) ) = sysInByte( (BYTE *)trans->dwPort );
				(BYTE *)trans->Data.pBuffer++;
				(BYTE *)trans->dwPort++;
			}
			break;
			
		case	RP_SDWORD:
			trans->dwBytes *= 1;
			for( li = 0; li < trans->dwBytes; li++)
			{
				*( (BYTE *)(trans->Data.pBuffer) ) = sysInByte( (BYTE *)trans->dwPort );
				(BYTE *)trans->Data.pBuffer++;
				(BYTE *)trans->dwPort++;
			}
			break;
		
		/////////////////////////
		case	WP_SBYTE:
			trans->dwBytes *= 1;
			for( li = 0; li < trans->dwBytes; li++)
			{
				sysOutByte( (BYTE *)trans->dwPort,*((BYTE *)trans->Data.pBuffer) );
				(BYTE *)trans->Data.pBuffer++;
				(BYTE *)trans->dwPort++;
			}
			break;
			
		case	WP_SWORD:
			trans->dwBytes *= 1;
			for( li = 0; li < trans->dwBytes; li++)
			{
				sysOutByte( (BYTE *)trans->dwPort,*((BYTE *)trans->Data.pBuffer) );
				(BYTE *)trans->Data.pBuffer++;
				(BYTE *)trans->dwPort++;
			}
			break;
			
		case	WP_SDWORD:
			trans->dwBytes *= 1;
			for( li = 0; li < trans->dwBytes; li++)
			{
				sysOutByte( (BYTE *)trans->dwPort,*((BYTE *)trans->Data.pBuffer) );
				(BYTE *)trans->Data.pBuffer++;
				(BYTE *)trans->dwPort++;
			}
			break;
		
		/////////////////////////////////////////////////////////////////////////////			
		default:
			pspandrv_printf("No such function!\n");
			
			break;
		
	}// end of switch
	
}// end of Transfer_pspan(WD_TRANSFER *trans)


/*******************************************************************************
* 	IntEnable_pspan 
*/
LOCAL int IntEnable_pspan( WD_INT *PSPAN_IntHandler )
{
    
	unsigned char irq_line;
	VOIDFUNCPTR* vector; 
	
	pciConfigInByte( PSPAN_IntHandler->pci.dwBus, PSPAN_IntHandler->pci.dwSlot, PSPAN_IntHandler->pci.dwFunction,\
			 PCI_ILR, &irq_line);
	pspandrv_printf("irq_line is 0x%x\n",irq_line);
    
	//irq_line = 0;//pgn++
	vector = INUM_TO_IVEC( irq_line + INT_NUM_IRQ0 );   
	pspandrv_printf("vector is 0x%x\n",vector);
	
	sysPciIntConnect(vector, PSPAN_IntHandler->int_routine, PSPAN_IntHandler->params); 
	sysIntEnablePIC(irq_line);
	
	return 0;
	
		
}


/*******************************************************************************
* 	IntDisable_pspan 
*/
LOCAL int IntDisable_pspan( WD_INT *PSPAN_IntHandler )
{
	unsigned char irq_line;
	VOIDFUNCPTR* vector; 
	
	pciConfigInByte( PSPAN_IntHandler->pci.dwBus, PSPAN_IntHandler->pci.dwSlot, PSPAN_IntHandler->pci.dwFunction,\
			 PCI_ILR, &irq_line);
	pspandrv_printf("IntDisable_pspan irq_line is 0x%x\n",irq_line);
	
	//irq_line = 0;//pgn++
	vector = INUM_TO_IVEC( irq_line + INT_NUM_IRQ0 );  
	pspandrv_printf("IntDisable_pspan vector is 0x%x\n",vector);
	 
	sysIntDisablePIC(irq_line);  
	sysPciIntDisconnect(vector, PSPAN_IntHandler->int_routine); 
	
	return 0;	
		
}