isp1581.cpp

EP9315开发板的Wince6.0的BSP包文件

    DWORD dwStatus;

//    DWORD dwCurrentPermissions = GetCurrentPermissions();
//    SetProcPermissions(pTransfer->dwCallerPermissions);
    
    __try
    {
        PBYTE  pbBuffer = (PBYTE) pTransfer->pvBuffer + pTransfer->cbTransferred;
        DWORD  cbBuffer = pTransfer->cbBuffer - pTransfer->cbTransferred;
        DWORD  cbRead;

        cbRead = UDC_USBReadEndpoint(pContext,peps,(unsigned char *)pbBuffer,cbBuffer, FALSE);
        DumpHexBuf((unsigned char*)pbBuffer, cbRead);

        pTransfer->cbTransferred += cbRead;

        if ( (pTransfer->cbTransferred >= pTransfer->cbBuffer) ||
             (cbRead % peps->wMaxPacketSize != 0) ) 
        {
            fCompleted = TRUE;
            dwStatus = UFN_NO_ERROR;
        }
    }
    __except(EXCEPTION_EXECUTE_HANDLER) {
        DEBUGMSG(ZONE_ERROR, (_T("Exception in HandleRx!\r\n")));
        fCompleted = TRUE;
        dwStatus = UFN_CLIENT_BUFFER_ERROR;
    }

//    SetProcPermissions(dwCurrentPermissions);

    if (fCompleted)
    {
        CompleteTransfer(pContext, peps, dwStatus);
    }

}

// Calls must be protected by the pTransfer->cs.
static
VOID
StartTransfer(
    PUSBSLAVE_PDD_CONTEXT pContext,
    PEP_STATUS peps,
    PSTransfer pTransfer
    )
{
    // Enable transfer interrupts.
    peps->pTransfer = pTransfer;

    SetClearTransferInterrupts(pContext, peps, pTransfer, SET);


    if (TRANSFER_IS_IN(pTransfer))
    {
//        RETAILMSG(1, ( TEXT("StartTransfer Tx %d bytes\r\n"), pTransfer->cbBuffer));
        HandleTx(pContext, peps);
    }
    else
    {
//        RETAILMSG(1, ( TEXT("StartTransfer Rx %d bytes\r\n"), pTransfer->cbBuffer));
        HandleRx(pContext, peps);
    }
}

DWORD
WINAPI
UfnPdd_IssueTransfer(
    PVOID  pvPddContext,
    DWORD  dwEndpoint,
    PSTransfer pTransfer
    )
{
    DWORD dwRet;

    PUSBSLAVE_PDD_CONTEXT pContext = (PUSBSLAVE_PDD_CONTEXT) pvPddContext;

    PEP_STATUS peps = GetEpStatus(pContext, dwEndpoint);
    LOCK_ENDPOINT(peps);
    DEBUGCHK(peps->fInitialized);

    StartTransfer(pContext, peps, pTransfer);

    dwRet = ERROR_SUCCESS;

    UNLOCK_ENDPOINT(peps);

    return dwRet;
}




DWORD
WINAPI
UfnPdd_AbortTransfer(
    PVOID           pvPddContext,
    DWORD           dwEndpoint,
    PSTransfer      pTransfer
    )
{
    SETFNAME();
    FUNCTION_ENTER_MSG();

    PUSBSLAVE_PDD_CONTEXT pContext   = (PUSBSLAVE_PDD_CONTEXT) pvPddContext;
    volatile unsigned short *pIOBASE =  (unsigned short *)pContext->pusTemIOBASE;

    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)) {
                // Clear FIFO
                /*WriteReg(pContext, peps->dwBaseOffset + EP_STAT_OFFSET, FIFO_FLUSH_MASK);*/
                //    
                // Select the appropriate endpoint.    
                //    
                pIOBASE[HwUSBEndpointIndex >> REG_ALIGN_OFFSET] = (unsigned short)(peps->dwEndpoint) ;
                //   
                // Send the clear buffer command so that the endpoint can receive   
                // another packet.   
                //   
                pIOBASE[HwUSBEndpointControl >> REG_ALIGN_OFFSET] |= USB_EPCONTROL_CLEAR;
            }
        }

        UNLOCK_ENDPOINT(peps);
    }
    
    FUNCTION_LEAVE_MSG();

    return ERROR_SUCCESS;
}


// Process an endpoint interrupt.  Call interrupt-specific handler.
static
VOID
HandleEndpointEvent(
    PUSBSLAVE_PDD_CONTEXT    pContext,
    DWORD               dwEndpoint
    )
{

    volatile unsigned short *pIOBASE =  (unsigned short *)pContext->pusTemIOBASE;
    PEP_STATUS peps = GetEpStatus(pContext, dwEndpoint);

    LOCK_ENDPOINT(peps);
    if(peps->pTransfer == NULL)
    {
        UNLOCK_ENDPOINT(peps);
        return;
    }

    if (TRANSFER_IS_IN(peps->pTransfer))
	{
        if (peps->pTransfer->cbTransferred == peps->pTransfer->cbBuffer)
        {
            CompleteTransfer(pContext, peps, UFN_NO_ERROR);
        }
        else
        {
            HandleTx(pContext, peps);
        }
	}
	else
	{
        HandleRx(pContext, peps);
	}
    UNLOCK_ENDPOINT(peps);

}

static
VOID
HandleSetupPacket(
    PUSBSLAVE_PDD_CONTEXT pContext
    )
{
    USB_DEVICE_REQUEST udr;

    //
    // Read the packet.
    //
    unsigned char *pucChar = (unsigned char *)&udr;
    unsigned long usLength = sizeof(USB_DEVICE_REQUEST);
    PEP_STATUS peps = GetEpStatus(pContext, USB_ENDPOINT_0);
    if(UDC_USBReadEndpoint(pContext,peps, pucChar,usLength, TRUE) != sizeof(USB_DEVICE_REQUEST))
    {
        //
        // The size of the setup packet is incorrect, so stall both of the
        // control endpoints.
        //
        USBStallEndpoint(pContext,USB_ENDPOINT_0, 1);
        RETAILMSG(1, ( TEXT("EP0--setup  read packet error,then stall\r\n") ) );
        
        return;

    }
    DumpHexBuf((unsigned char*)&udr, 8);
    pContext->pfnNotify(pContext->pvMddContext, UFN_MSG_SETUP_PACKET, (DWORD) &udr);

}

//****************************************************************************
//
// USBISR -------USB Slave isr
//
//****************************************************************************
void
USBISR (PUSBSLAVE_PDD_CONTEXT pContext)
{
    unsigned long ulIntStatus;
    unsigned short  ulIntStatusLow;
    unsigned short  ulIntStatusHigh;
//    unsigned char  * pucChar;
//    unsigned long  usLength;

    volatile unsigned short *pIOBASE =  (unsigned short *)pContext->pusTemIOBASE;

    ulIntStatusLow  = pIOBASE[HwUSBIntReason >> REG_ALIGN_OFFSET] ;
    ulIntStatusHigh = pIOBASE[(HwUSBIntReason >> REG_ALIGN_OFFSET) + 1];
    
    //
    //Sleep 10ms/5ms/1ms/500us/100us
    //
    DelayuS(100);
//	Sleep(50);
    //
    // Clear the interrupt reason register.
    //
    pIOBASE[HwUSBIntReason >> REG_ALIGN_OFFSET] = ulIntStatusLow;
    pIOBASE[(HwUSBIntReason >> REG_ALIGN_OFFSET) + 1] = ulIntStatusHigh;

    ulIntStatus = (ulIntStatusHigh<<16) + ulIntStatusLow;
    
    //
    // Handle a hs status change.
    //
    if(ulIntStatus & USB_INT_HS_STATUS)
    {
  		//
        // Reconfigure the ISP1581.
        //  
        DelayuS(100);

        pContext->pfnNotify(pContext->pvMddContext, UFN_MSG_BUS_SPEED, BS_HIGH_SPEED);
    }

    //
    // Handle a bus reset.
    //
    if(ulIntStatus & USB_INT_BUS_RESET)
    {
   
		//
        // Reconfigure the ISP1581.
        //
        DelayuS(100);

        
//		RETAILMSG(1, ( TEXT("USB_INT_RESET_STATUS enter \r\n")) );
        USBChipEnable(pContext, FALSE);
        pContext->pfnNotify(pContext->pvMddContext, UFN_MSG_BUS_EVENTS,UFN_RESET);
		if(pContext->DeviceStatus!=UFN_ATTACH)
		{
			pContext->DeviceStatus=(DEVICE_STATUS)UFN_ATTACH;
     		pContext->pfnNotify(pContext->pvMddContext, UFN_MSG_BUS_EVENTS, UFN_ATTACH);
		}
		//By default set as Full Speed
        if(!(ulIntStatus & USB_INT_HS_STATUS))
    		pContext->pfnNotify(pContext->pvMddContext, UFN_MSG_BUS_SPEED, BS_FULL_SPEED);
    }

    //
    // Handle an interrupt on the bulk out endpoint.
    //
    if(ulIntStatus & (USB_INT_EP0_RX | USB_INT_EP0_TX ) )
    {
//    	RETAILMSG(1, ( TEXT("EP0 int enter \r\n")) );
        HandleEndpointEvent(pContext,USB_ENDPOINT_0);
    }
    if(ulIntStatus & (USB_INT_EP1_RX | USB_INT_EP1_TX ) )
    {
//    	RETAILMSG(1, ( TEXT("EP1 int enter \r\n")) );
        HandleEndpointEvent(pContext,USB_ENDPOINT_1);
    }
    if(ulIntStatus & (USB_INT_EP2_RX | USB_INT_EP2_TX ) )
    {	
//    	RETAILMSG(1, ( TEXT("EP2 int enter \r\n")) );
        HandleEndpointEvent(pContext,USB_ENDPOINT_2);
    }
    if(ulIntStatus & (USB_INT_EP3_RX | USB_INT_EP3_TX ) )
    {
        HandleEndpointEvent(pContext,USB_ENDPOINT_3);
    }
    if(ulIntStatus & (USB_INT_EP4_RX | USB_INT_EP4_TX ) )
    {
        HandleEndpointEvent(pContext,USB_ENDPOINT_4);
    }
    if(ulIntStatus & (USB_INT_EP5_RX | USB_INT_EP5_TX ) )
    {
        HandleEndpointEvent(pContext,USB_ENDPOINT_5);
    }
    if(ulIntStatus & (USB_INT_EP6_RX | USB_INT_EP6_TX ) )
    {
        HandleEndpointEvent(pContext,USB_ENDPOINT_6);
    }
    if(ulIntStatus & (USB_INT_EP7_RX | USB_INT_EP7_TX ) )
    {
        HandleEndpointEvent(pContext,USB_ENDPOINT_7);
    }
    
    //
    // Handle an interrupt from a setup packet.
    //
    if(ulIntStatus & USB_INT_EP0_SETUP)
    {
        HandleSetupPacket(pContext);
    }
    


}

//****************************************************************************
//
//USBSlaveIntrThread--- USB Slave Device ISR Thread
//
//*****************************************************************************
static DWORD WINAPI USBSlaveIntrThread(LPVOID lpParameter)
{

    PUSBSLAVE_PDD_CONTEXT pContext = (PUSBSLAVE_PDD_CONTEXT) lpParameter;
    volatile unsigned short *pIOBASE =  (unsigned short *)pContext->pusTemIOBASE;
    
    pContext->pfnNotify(pContext->pvMddContext,UFN_MSG_BUS_EVENTS, UFN_ATTACH);
    while(!pContext->fExitIST)
    {
        WaitForSingleObject (pContext->hevInterrupt, INFINITE);

        //
        // Disable Interrupt
        //
        pIOBASE[HwUSBMode >> REG_ALIGN_OFFSET] &= (~USB_MODE_INT_ENABLE);
        //
        //USB Slave Driver ISR
        //
        USBISR (pContext);

        InterruptDone(pContext->dwSysIntr);

        //
        // Enable Interrupt
        //
        pIOBASE[HwUSBMode >> REG_ALIGN_OFFSET] |= USB_MODE_INT_ENABLE;

    }

    pContext->pfnNotify(pContext->pvMddContext, UFN_MSG_BUS_EVENTS, UFN_DETACH);

    pContext->fSpeedReported = FALSE;
    pContext->fAttached = FALSE;
    return 0;

}

//****************************************************************************
//
//TestUSBChipID----test the Chip ID of the USB Device Controll Chip
//                   to make sure the USB daughter board connect to EP93xx
//                   return 0 sucess
//                       1 fail
//
//*****************************************************************************
BOOL TestUSBChipID(PUSBSLAVE_PDD_CONTEXT    pContext)
{
    volatile unsigned long ulChipID1,ulUSBSlaveChipIDVersion;

    volatile unsigned short *pIOBASE =  (unsigned short *)pContext->pusTemIOBASE;

    ulChipID1 = pIOBASE[HwUSBChipID >> REG_ALIGN_OFFSET] + 
        (pIOBASE[(HwUSBChipID >> REG_ALIGN_OFFSET) + 1] << 16);

    if ( (ulChipID1 & USB_CHIPID_ID_MASK) == USB_CHIPID_ID)
    {
        ulUSBSlaveChipIDVersion = (ulChipID1&USB_CHIPID_VERSION_MASK);
        return (1);
    }

    RETAILMSG(1, ( TEXT("Could not find the ISP1581 !!!\r\n")));
    return (0);

}

//****************************************************************************
//
//InitIOMap----map the IO addrress of the USB Device Controll Chip
//              And init the SMC
//              return 0 sucess
//                     1 fail
//Cs7
//*****************************************************************************

BOOL InitIOMap ( PUSBSLAVE_PDD_CONTEXT    pContext )
{
    ULONG ret;
    PUSHORT IOBASE  =   NULL;
    //
    //Mapping USB Slave  Registers
    //
    IOBASE=(USHORT *)VirtualAlloc( NULL, 0x100, MEM_RESERVE, PAGE_READWRITE );
    if ( IOBASE == NULL )
    {
        goto error_return;
    }

    ret = VirtualCopy( 
        (LPVOID)IOBASE,
        (LPVOID)(PHYSICAL_ADDR_ASYNC_CS7>>8), 
        0x100,
        PAGE_READWRITE | PAGE_NOCACHE | PAGE_PHYSICAL 
        );
    if ( ret == FALSE )
    {
        goto error_return;
    }

    //
    //Set 931xArm Memory Configuration Registers
    //Static memory controller SMC(SMC_SMCBCR7)
    //Here we use SMC7(0x8008001c) RBWX bit(cs7)
    //
    *((PULONG)(SMC_SMCBCR7)) = 0x1000ffe0;


    pContext->pusTemIOBASE  =   (unsigned long)IOBASE;
    return TRUE;

error_return:

     VirtualFree((PVOID)IOBASE, 0, MEM_RELEASE);
     IOBASE=0;

     return FALSE;

}

//****************************************************************************
//
//ReleaseIOMap----release the IO addrress of the USB Device Controll Chip
//
//*****************************************************************************
void ReleaseIOMap ( PUSBSLAVE_PDD_CONTEXT    pContext )