z228_usb_msc.cpp

此压缩包为杰得开发得z228的BSP的源代码,可以实现很多功能,尤其是视频解码有很好的效果.

    PSTransfer pTransfer = peps->pTransfer;
	
    peps->pTransfer = NULL;    
    
    // Disable transfer interrupts until another transfer is issued.
    SetClearTransferInterrupts(pContext, peps, pTransfer, CLEAR);   
          
    //SetProcPermissions(pTransfer->dwCallerPermissions); 
    pTransfer->dwUsbError = dwUsbError;
    pContext->pfnNotify(pContext->pvMddContext, UFN_MSG_TRANSFER_COMPLETE, (DWORD) pTransfer);
    if(peps->dwEndpoint & pContext ->fFunction)
	 pContext ->fFunction  = FALSE;
	
    //SetProcPermissions(pTransfer->dwCallerPermissions);
    
    //RETAILMSG(1, (_T("- CompleteTransfer %x %d\r\n"), pTransfer->dwFlags,dwUsbError));
   
}


DWORD
WINAPI
UfnPdd_AbortTransfer(
    PVOID           pvPddContext,
    DWORD           dwEndpoint,
    PSTransfer      pTransfer
    )
{
    PREFAST_DEBUGCHK(pTransfer);
    DEBUGCHK(EP_VALID(dwEndpoint));
    RETAILMSG(USB_INIT, (_T("+UfnPdd_AbortTransfer\r\n")));

    PZ228_CONTEXT pContext = (PZ228_CONTEXT) pvPddContext;
    ValidateContext(pContext);

    PEP_STATUS peps = GetEpStatus(pContext, dwEndpoint);

    if (peps->fInitialized) {
        LOCK_ENDPOINT(peps);
        
        if (pTransfer == peps->pTransfer) {
            ValidateTransferDirection(pContext, peps, pTransfer);
            CompleteTransfer(pContext, peps, UFN_CANCELED_ERROR);
			
	    /*	
            if (TRANSFER_IS_IN(pTransfer)) {               
            }
            */
         }
        UNLOCK_ENDPOINT(peps); 
    }   

    return ERROR_SUCCESS;
}


// Process an endpoint interrupt.  Call interrupt-specific handler.
// handle point 0
static
VOID
HandleEndpoint0Event(
    PZ228_CONTEXT pContext,
    DWORD            dwEndpoint,
    BOOL ep_intr
    )
{
    DWORD sr;
    DWORD ep_num = (usb_read(UDC_RX_STATUS) >> UDC_RX_ENDP_SHIFT) & UDC_RX_ENDP_MASK;
    dwEndpoint = ep_num;
    PEP_STATUS peps = GetEpStatus(pContext, dwEndpoint);
    LOCK_ENDPOINT(peps);

  //  RETAILMSG(USB_DEBUG, (_T("%s ++ (%c)\r\n"), pszFname,   GET_ENDPOINT_LETTER(peps->dwEndpoint)));
 //   RETAILMSG(USB_DEBUG, (_T("UDC_TX_STATUS(0) = 0x%08x\r\n"),usb_read(UDC_TX_STATUS(0))));
//   RETAILMSG(USB_DEBUG, (_T("UDC_ENDP_INTR= 0x%08x\r\n"),usb_read(UDC_ENDP_INTR) & ENDP_INTR_MASK));
    ValidateContext(pContext);    

    if (!peps->fInitialized) {
        // This endpoint must have just been deinitialized.
        return;
    }

    DEBUGCHK(pContext->fRunning); 
		
   //RETAILMSG(1,(TEXT("point =%d  ep = %d ep_intr=%d\r\n"),dwEndpoint,ep_num,ep_intr));
   
    DEBUGMSG(USB_DEBUG,(_T("rx count = %3d epNE= %d pipeNE=%d\r\n"),(sr>>22)&1023,ep_num,peps->dwEndpoint));
    if(ep_num == 0){
	sr = usb_read(UDC_RX_STATUS);
	DEBUGMSG(USB_DEBUG, (_T("UDC_RX_STATUS = %x\r\n"),sr));
	if (sr & UDC_RX_THRESH_ABOVE) {
		DWORD count = (usb_read(UDC_THRESHOLD) >> UDC_RX_THRESH_SHIFT) & UDC_RX_THRESH_MASK;
		if (count == 0) {
				usb_write(UDC_RX_FIFOREADY, UDC_RX_CONTROL(0));
				//	flush(ep);
		} else{
				DEBUGMSG(USB_DEBUG, (_T("Please read out the data\r\n")));
		}
	}

	// Previous Control transfer OK 
	 if (sr & UDC_RX_STATUS_COMPLETE){
			if (sr & UDC_RX_GOOD_STATUS)	{
				usb_set(UDC_RX_STATUS_COMPLETE, UDC_RX_STATUS);
				usb_write(UDC_RX_FIFOREADY, UDC_RX_CONTROL(0));
			}
	  }
	}    
	if (peps->pTransfer && TRANSFER_IS_OUT(peps->pTransfer)){
		//	RETAILMSG(USB_DEBUG, (_T("HandleRx()\r\n")));
			HandleRx(pContext, peps);
	}   
       UNLOCK_ENDPOINT(peps);
}

// handle the point
static
VOID
HandleEndpointEvent(
    PZ228_CONTEXT 		pContext,
    DWORD            			dwEndpoint,
    BOOL 					ep_intr
    )
{
  	//RETAILMSG(1, (_T("+HandleEndpointEvent %d\r\n"), dwEndpoint));
  	PEP_STATUS peps = GetEpStatus(pContext, dwEndpoint);
  	
    	ValidateContext(pContext);
    	DEBUGCHK(pContext->fRunning);  
   
     	LOCK_ENDPOINT(peps);
     	if (!peps->fInitialized) {
        	// This endpoint must have just been deinitialized.        	
        	UNLOCK_ENDPOINT(peps);
        	return;
     	}
	
     	PSTransfer pTransfer = peps->pTransfer;
     	DWORD     dwEpIntr = usb_read(UDC_ENDP_INTR);
		
     	if((peps->dwFlags & dwEpIntr) == 0)	{
		  RETAILMSG(USB_ERROR, (_T(" EP (%d) Intr = 0x%x!\r\n"), dwEndpoint, usb_read(UDC_ENDP_INTR)));
		  UNLOCK_ENDPOINT(peps);
		  return;
	}
	
	if (pTransfer){
              if (TRANSFER_IS_IN(pTransfer)) { 	        	   		             
		       // All of the data has been written to the FIFO.
		        // The FIFO has been emptied so this transfer is 
		        // really complete.
		   	DWORD TxStatus = usb_read(UDC_TX_STATUS(dwEndpoint));
		   	if(TxStatus & UDC_TX_DATASENT)  {
			 	usb_set(UDC_TX_DATASENT,UDC_TX_STATUS(dwEndpoint));	 	
			 	usb_set(UDC_TX_NAKSENT,UDC_TX_STATUS(dwEndpoint));		         
			 	if (pTransfer->cbTransferred == pTransfer->cbBuffer) 				  
		                	 CompleteTransfer(pContext, peps, UFN_NO_ERROR);
			 	else
			 	   	HandleTx(pContext, peps);
		 	}  
		   	  else   {
		                // else the FIFO has not been emptied--there are still packets
		                // that need to be sent for this transfer.
		      		 if (pTransfer->cbTransferred != pTransfer->cbBuffer) 
		            	      HandleTx(pContext, peps);
	      		}			 
       	}		 
    	}
	
    	UNLOCK_ENDPOINT(peps);
}

// Get the current speed and report it to the MDD.
inline
static
VOID
ReportSpeed(
    PZ228_CONTEXT pContext
    )    
{  
        RETAILMSG(USB_DEBUG, (_T("+ReportSpeed\r\n")));    
        pContext->pfnNotify(pContext->pvMddContext, UFN_MSG_BUS_SPEED, BS_FULL_SPEED);
}

static
VOID
HandleSetupPacket(
    PZ228_CONTEXT pContext,
    DWORD dev_intr
    )
{
    DWORD setup_sr;
    PEP_STATUS peps = GetEpStatus(pContext, 0);
    DEBUGCHK(pContext);
   // RETAILMSG(USB_DEBUG, (_T("+HandleSetupPacket ()\r\n")));

    if (!pContext->fSpeedReported) {
        	ReportSpeed(pContext);
        	pContext->fSpeedReported = TRUE;
    }
 
    USB_DEVICE_REQUEST udr;
    PDWORD pdwUdr = (PDWORD) &udr;    
    if(dev_intr & UDC_SETCFG_INTR)  {	
	     	udr.bmRequestType = USB_REQUEST_FOR_DEVICE;		//0x00
            	udr.bRequest = USB_REQUEST_SET_CONFIGURATION;  	//0x09
            	udr.wValue =usb_read(UDC_STATUS) && UDC_STATUS_CFG_MASK;
            	udr.wIndex = 0 ;
            	udr.wLength = 0;
		
		//RETAILMSG(USB_DATA_OUT, (_T("SetupPacket:	0x%08x   0x%08x		UDC_SETCFG_INTR\r\n"),*pdwUdr,*(pdwUdr+1)));
		usb_set(UDC_SETCFG_INTR, UDC_INTR);			
		if (udr.wValue !=	0){
	   		 pContext->pfnNotify(pContext->pvMddContext, UFN_MSG_SETUP_PACKET, (DWORD) &udr);
		}
		else{
				DEBUGMSG(USB_DEBUG, (_T("no Notify!!!\r\n")));
		}		
		usb_write(UDC_RX_FIFOREADY, UDC_RX_CONTROL(0));
	}
	  else if(dev_intr&UDC_SETINTF_INTR){ 

	     	udr.bmRequestType = USB_REQUEST_FOR_DEVICE;		//0x00
            	udr.bRequest = USB_REQUEST_SET_INTERFACE;               //0x0B
            	udr.wValue = (usb_read(UDC_STATUS) >> UDC_STATUS_INTF_SHIFT) && UDC_STATUS_INTF_MASK;
            	udr.wIndex = 	0x0 ;
            	udr.wLength = 0x0;
				
		//RETAILMSG(USB_DATA_OUT, (_T("SetupPacket:	0x%08x   0x%08x		UDC_SETINTF_INTR\r\n"),*pdwUdr,*(pdwUdr+1)));
		usb_set(UDC_SETINTF_INTR, UDC_INTR);
		usb_write(UDC_RX_FIFOREADY, UDC_RX_CONTROL(0));
	    	pContext->pfnNotify(pContext->pvMddContext, UFN_MSG_SETUP_PACKET, (DWORD) &udr);

	}
	  else if(dev_intr & UDC_SETUP_REV_INTR)	{

		setup_sr = usb_read(UDC_SETUP_STATUS);
              
		// Clear setup after out  Flag */
		if (setup_sr & UDC_SETUP_AFTER_OUT) 
				usb_set(UDC_SETUP_AFTER_OUT, UDC_SETUP_STATUS);
			
		if (setup_sr & UDC_SETUP_STATUS_COMPLETE) {
			usb_set(UDC_SETUP_STATUS_COMPLETE, UDC_SETUP_STATUS);
			
			if (setup_sr & UDC_SETUP_GOOD_STATUS) {
				*pdwUdr = usb_read(UDC_SETUP_DATA_LOW);
				*(pdwUdr + 1)  = usb_read(UDC_SETUP_DATA_HIGH);
				RETAILMSG(USB_DATA_OUT, (_T("SetupPacket:	0x%08x   0x%08x\r\n"),*pdwUdr,*(pdwUdr+1)));				
			}
			else {
				RETAILMSG(USB_DATA_OUT, (_T("@\r\n")));
			}
		}
		
		usb_write(UDC_RX_FLUSHFIFO |UDC_RX_FIFOREADY, UDC_RX_CONTROL(0));    
		if(pContext->fFunction)
   		    	pContext->pfnNotify(pContext->pvMddContext, UFN_MSG_SETUP_PACKET, (DWORD) &udr);	

              // Fix some class packet 
		if( *(char *)pdwUdr == 0x21 )  {
				  UfnPdd_SendControlStatusHandshake(pContext, 1);
				  RETAILMSG(1, (_T("HandleSetupPacket:  0x%x \r\n"), usb_read(UDC_ENDP_INTR_ENABLE)));
		}
	}		
}


static
VOID
HandleBusEvent(
    PZ228_CONTEXT pContext,
    DWORD dev_intr
    )
{
 
    	RETAILMSG(USB_DEBUG, (_T("+HandleBusEvent\r\n")));

       //dev_intr = (usb_read(UDC_INTR) & UDC_INTR_MASK);
	if (dev_intr){
		// USB OTG Suspend Interrupt 
		  if (dev_intr & UDC_SUSPEND_INTR) 	{
		  	       usb_set(UDC_SUSPEND_INTR, UDC_INTR);
				RETAILMSG(USB_DEBUG, (_T("suspend Intr\r\n")));
				if(pContext->fAttached == TRUE)      {
                                   pContext->pfnNotify(pContext->pvMddContext,UFN_MSG_BUS_EVENTS, UFN_DETACH);
                                   pContext->fAttached = FALSE;
			     }
			    //delay for a while waiting upper level DETACH
			      Sleep(200);
			     
		}			 
		// USB OTG SOF Interrupt: TODO
		if (dev_intr & UDC_SOF_INTR) {		 
				RETAILMSG(USB_DEBUG, (_T("			SOF Interrupt\r\n")));
				usb_set(UDC_SOF_INTR, UDC_INTR);
		}
               
		  // USB OTG SOF Interrupt: TODO		
		if (dev_intr & UDC_PORT_STATUS_INTR) {
				RETAILMSG(USB_DEBUG, (_T("			Device Port Status Interrupt\r\n")));
				usb_set(UDC_PORT_STATUS_INTR, UDC_INTR);
		}
		
		 // USB OTG Status Interrupt: TODO 
		 if (dev_intr & UDC_OTG_STATUS_INTR) {	
			DWORD dwID_Change, dwMode;
				
			RETAILMSG(USB_DEBUG, (_T("	OTG Status Intr\r\n")));				
			dwID_Change = usb_read(UHC_OTG_CSR)& UHC_CONN_ID_CHANGE;
	              if(dwID_Change)   {		  	      
			      usb_write(UHC_CONN_ID_CHANGE, UHC_OTG_CSR);          	  
                           // reset the otg controller
                           //z228_Hw_Init();
			  
		              // read the OTG status
		             dwMode = (usb_read(UHC_OTG_CSR)&OTG_MODE_DEVICE)? DEV_MODE : HOST_MODE;
                           if(dwMode == HOST_MODE)   {
                           	   RETAILMSG(1, (_T("Device:  OTG Status Intr set event\r\n")));		
                                   pContext->fExitIST = TRUE;
								   
		                     // send event to  the mainthread
		                     SetEvent(pContext->hevDevEvent);
					Sleep(100);	
                          }		          
	              }
                     usb_set(UDC_OTG_STATUS_INTR, UDC_INTR); 
		}
		 
		// USB OTG I2C Interrupt: TODO 
		if (dev_intr & UDC_I2C_INTR) {
				RETAILMSG(USB_DEBUG, (_T("		  I2C Interrupt\r\n")));
				usb_set(UDC_I2C_INTR, UDC_INTR);
		}			

		// USB OTG Bus Reset Interrupt 
		if(dev_intr & UDC_BUSRESET_INTR) {			     
				RETAILMSG(USB_INIT, (TEXT("		Reset Intr\r\n")));
				if(pContext->fFunction)
				      z228_reset_intr(pContext);
				usb_set(UDC_BUSRESET_INTR, UDC_INTR);
		}
               
		DEBUGMSG(USB_DEBUG, (_T("		UDC_INTR = 0x%x\r\n"),	usb_read(UDC_INTR)));
              
	}
}

// Process a z228 interrupt.
static
VOID
HandleUSBEvent(
    PZ228_CONTEXT pContext
    )
{
	DWORD dev_intr,ep_intr;
	UCHAR iCount = 0;
	BOOL   fStop = FALSE;
	  	
    //RETAILMSG(1, (_T("500 DEBUG: 1\r\n")));
    dev_intr = (usb_read(UDC_INTR));
	  ep_intr = (usb_read(UDC_ENDP_INTR) & ENDP_INTR_MASK);
	  while (ep_intr ||(dev_intr&(UN_BUS_INTR|UDC_OUT_REV_INTR|(UDC_SETCFG_INTR|UDC_SETINTF_INTR)))) {
		   iCount++;
		   if (dev_intr & UN_BUS_INTR) {
			     //DEBUGMSG(USB_DEBUG, (_T("500K Debug:   Bus Notify\r\n")));
	         HandleBusEvent(pContext, dev_intr);
	     }
       if(dev_intr & (UDC_SETUP_REV_INTR | UDC_SETCFG_INTR | UDC_SETINTF_INTR)) {
	        //DEBUGMSG(USB_DEBUG, (_T("		(Setup) Interrupt!  epNE=%d \r\n"),(usb_read(UDC_SETUP_STATUS) >> UDC_SETUP_ENDP_SHIFT) & UDC_RX_ENDP_MASK));
			     HandleSetupPacket(pContext,dev_intr);
	     }
	     		
       if(usb_read(UDC_INTR) & UDC_SUSPEND_INTR)	   {
           RETAILMSG(USB_DEBUG, (_T("suspend Intr2\r\n")));
			     usb_set(UDC_SUSPEND_INTR, UDC_INTR);
			     fStop = TRUE;
			     //z228_suspend_intr(pContext);			   
		   }

		   /* USB OTG Out Packet Recieved Interrupt */				
		   if (dev_intr & UDC_OUT_REV_INTR) {
			     HandleEndpoint0Event(pContext, 0, 0);				
			     usb_set(UDC_OUT_REV_INTR, UDC_INTR);
		   }
           
		   if(pContext->fAttached == FALSE)
		  	          Sleep(2);
		  	          
	     // Process All  Endpoints
	     ep_intr = (usb_read(UDC_ENDP_INTR) & ENDP_INTR_MASK);
	     if(ep_intr )  { 
		 RETAILMSG(USB_DATA_IN,(TEXT("ep_intr = 0x%x\r\n"), ep_intr));
               for (DWORD dwEndpoint = 0; dwEndpoint < 3; ++dwEndpoint)		{
                     PEP_STATUS peps = GetEpStatus(pContext, dwEndpoint);				  
				        if(ep_intr & peps->dwFlags)			{
			              	HandleEndpointEvent(pContext, dwEndpoint, 1);
						          usb_set(peps->dwFlags, UDC_ENDP_INTR);
					 }
					     					
				       if(usb_read(UDC_INTR) & UDC_SUSPEND_INTR)   {
                      RETAILMSG(USB_DEBUG, (_T("suspend Intr3\r\n")));
			                usb_set(UDC_SUSPEND_INTR, UDC_INTR);
						          fStop = TRUE;
						          break;
		          }		         
		       }          
		   }
		   if(fStop) {
                     z228_suspend_intr(pContext);
		   }		   
		   if(iCount>10)  
		            break;
	     dev_intr = usb_read(UDC_INTR);
		   ep_intr = (usb_read(UDC_ENDP_INTR) & ENDP_INTR_MASK);		   
		 }
}

//test thread
static
DWORD
WINAPI
ISTMain1(
    LPVOID lpParameter
    )
{
     PZ228_CONTEXT pContext = (PZ228_CONTEXT) lpParameter;
     int value = -1;
     OEM_IOCTL_GPIO gpio;
     
     RETAILMSG(1, (_T("+ISTMain1\r\n")));
     CeSetThreadPriority(pContext->hIST, pContext->dwISTPriority);     
    
      // Force into full speed mode if required.