usbser.c

6410BSP3

                else
                    m_fConnected = FALSE;
                    
                break;
               
            default:
                USBDBGMSG(USBDBG_ZONE_ERROR, (
                    L"ERROR!UsbDbg:Unrecognized Setup request. "
                    L"bmRequestType=0x%x. bRequest=0x%x\r\n",
                    pUdr->bmRequestType,
                    pUdr->bRequest
                ));
                break;
        }
    }

    //a standard request
    //
    else
    {
        switch(pUdr->bRequest) {
            case USB_REQUEST_GET_STATUS:
                if( (pUdr->bmRequestType == (USB_REQUEST_DEVICE_TO_HOST | USB_REQUEST_FOR_DEVICE)) 
                    || (pUdr->bmRequestType == (USB_REQUEST_DEVICE_TO_HOST | USB_REQUEST_FOR_INTERFACE)))
                {
                    fSendRecvStatusACK = ProcessGetStatus(pUdr);
                }
                else 
                {
                    USBDBGMSG(USBDBG_ZONE_WARN, (
                        L"WARN!UsbDbg:RequestType==0x%d, Unrecognzied"
                        L"or unsupported request\r\n", pUdr->bmRequestType
                        ));
                }
                break;

            case USB_REQUEST_CLEAR_FEATURE:
                if (pUdr->bmRequestType == 0x02)
                    USBDBGMSG(USBDBG_ZONE_WARN, (
                        L"WARN!UsbDbg:***RequestType==0x02\r\n"
                        ));
                break;

            case USB_REQUEST_SET_FEATURE:
                if (pUdr->bmRequestType == 0x02)
                    USBDBGMSG(USBDBG_ZONE_WARN, (
                        L"WARN!usbdbg:***RequestType==0x02\r\n"));
                break;

            case USB_REQUEST_SET_ADDRESS:
                USBDBGMSG(USBDBG_ZONE_VERBOSE, (
                    L"usbdbg:Recvd. USB_REQUEST_SET_ADDRESS.\r\n"));
                break;

            case USB_REQUEST_GET_DESCRIPTOR:
                fSendRecvStatusACK = SendDescriptor(pUdr);
                break;

            case USB_REQUEST_SET_DESCRIPTOR:
                break;

            case USB_REQUEST_GET_CONFIGURATION:
                break;

            case USB_REQUEST_SET_CONFIGURATION:
                break;

            case USB_REQUEST_GET_INTERFACE:
                break;

            case USB_REQUEST_SET_INTERFACE:
                break;

            case USB_REQUEST_SYNC_FRAME:
                break;

            default:
                USBDBGMSG(USBDBG_ZONE_WARN, (
                    L"WARN!usbdbg:***Unknown request 0x%x\r\n", pUdr->bRequest
                ));
        }
    }   // end of else for standard request

    if (fSendRecvStatusACK)
    {
        if (USBFN_IS_OUT_REQUESTTYPE(pUdr->bmRequestType))//Host->Device request
            SendControlStatusHandshake();
        else    // Device->Host request
            RecvControlStatusHandshake();
    }
    USBDBGMSG(USBDBG_ZONE_FUNC, (L"usbdbg: -ProcessSetupPacket\r\n"));
    
}

       
// get end pt max pkt sizes from PDD
//
static
BOOL
UpdateUSBDesc(
    )
{
    UINT32 epNum;

    // get end pt max size from PDD
    for (epNum=0; epNum <= MAX_ENDPT; epNum++)
    {
        if (!m_pddIfc.pfnIoctl(
                USBDBG_PDD_IOCTL_ENDPT_MAXPACKETSIZE,
                (LPVOID) &epNum,
                sizeof(epNum),
                (LPVOID) &m_epMaxPktSize[epNum],
                sizeof(m_epMaxPktSize[epNum]),
                NULL))
        {
            USBDBGMSG(USBDBG_ZONE_ERROR, (
                L"ERROR!usbdbg: Failed to retrieve maxpacketsize from PDD "
                L"for ep=%d\r\n", epNum));
            return FALSE;
        }
    }
    
    m_deviceDesc.pUsbDeviceDescriptor->bMaxPacketSize0 = 
            (UCHAR) m_epMaxPktSize[CONTROL_ENDPT];
    m_pBulkOutEndPtDesc->wMaxPacketSize = (WORD) m_epMaxPktSize[BULKOUT_ENDPT];
    m_pBulkInEndPtDesc->wMaxPacketSize = (WORD) m_epMaxPktSize[BULKIN_ENDPT];
//    m_pIntInEndPtDesc->wMaxPacketSize = (WORD) m_epMaxPktSize[INTIN_ENDPT];

    return TRUE;
}

///=============================================================================
/// Public Functions (serifc -> UsbSerial)
///=============================================================================



// Called by serifc to deinitialize
//
void
UsbSerial_Deinit(
    )
{
    // abort all transfers
    AbortTransfers(TRUE, TRUE);

    // disconnect
    m_pddIfc.pfnDisconnect();

    // deinit
    m_pddIfc.pfnDeinit();
}

// Called by serifc & UsbSerial to get "interesting" events from PDD
//
UINT32
UsbSerial_EventHandler(
    )
{
    USBDBG_MSG msg = USBDBG_MSG_NOMSG;
    DWORD retVal;
    DWORD epNum;
    static USB_DEVICE_REQUEST pendingUdr;
    static BOOL fProcessingSetupRequest = FALSE;
    

    USBDBGMSG(USBDBG_ZONE_FUNC, (L"usbdbg:+UsbSerial_EventHandler\r\n"));
        
    // call PDD to get any interesting events
    retVal = m_pddIfc.pfnEventHandler(&msg, &m_MsgParamBuf[0]);

    //quit if error
    if (retVal != ERROR_SUCCESS)
    {
        USBDBGMSG(USBDBG_ZONE_ERROR, (
            L"ERROR!UsbDbg: UsbSerial_EventHandler\r\n"));
        goto clean;
    }

    switch (msg)
    {
        // a packet received on an EP
        case USBDBG_MSG_EP_RX_PKT:
        {
            epNum = *((DWORD*)m_MsgParamBuf);
            ContinueRxTransfer(epNum);
            break;
        }
        // a packet sent on an EP
        case USBDBG_MSG_EP_TX_PKT:
        {
            epNum = *((DWORD*)m_MsgParamBuf);
            ContinueTxTransfer(epNum);
            break;
        }
        // set up packet recvd
        case USBDBG_MSG_SETUP_PACKET:
        {
            USB_DEVICE_REQUEST udr = *((USB_DEVICE_REQUEST*) m_MsgParamBuf);

            // if a transfer is already in progress on EP0, mark this 
            // setup packet pending and return to unwind stack.
            if (fProcessingSetupRequest)
            {
                m_fSetupCancelled = TRUE;
                pendingUdr = udr;

                // stop any transfers on EP0
                if (m_epTransfers[0].status & USBDBG_TRANSFER_STATUS_INPROGRESS)
                {
                    AbortTransfer(CONTROL_ENDPT, ENDPT_DIR_RX);
                    AbortTransfer(CONTROL_ENDPT, ENDPT_DIR_TX);
                }
                goto clean;
            }
            else
            {  
                m_fSetupCancelled = FALSE;
            }
            

            fProcessingSetupRequest = TRUE;
            
            ProcessSetupPacket(&udr);

            fProcessingSetupRequest = FALSE;

            // while a setup packet was being processed another might have come
            // in. udr's processing was cancelled and the pending udr was stored
            // in m_pendingUdr.
            while (m_fSetupCancelled)
            {
                m_fSetupCancelled = FALSE;
                fProcessingSetupRequest = TRUE;
                 ProcessSetupPacket(&pendingUdr);
                fProcessingSetupRequest = FALSE; 
            }
            break;
        }

        case USBDBG_MSG_BUS_EVENT_DETACH:
        case USBDBG_MSG_BUS_EVENT_SUSPEND:
        case USBDBG_MSG_BUS_EVENT_RESET:
        {
            // set disconnected
            m_fConnected = FALSE;

            // abort all transfers
            AbortTransfers(TRUE, TRUE);

            // bus speed is determined, update ep's maxpktsize
            UpdateUSBDesc();

            break;
        }

        default:
            break;
    }
        
clean:
    USBDBGMSG(USBDBG_ZONE_FUNC, (L"usbdbg:-UsbSerial_EventHandler.msg=%d\r\n",
                msg));
    return msg;
}

// Called by serifc to receive data packets (over BULKOUT_ENDPT)
//
UINT32                           
UsbSerial_RecvData(
    PBYTE pbBuffer,       /* (IN) pointer to received data buffer */
    DWORD cbBufSize       /* (IN) received data buffer length */
    )
{
    DWORD cbRecvdData = 0;
    DWORD epNum = BULKOUT_ENDPT;    // data comes in on BULK OUT EP1
    DWORD retryCnt = 0;
    EPTransfer* pTransfer = &m_epTransfers[epNum];

#define RECV_RETRY_COUNT 20

    USBDBGMSG(USBDBG_ZONE_FUNC, (L"usbdbg:+UsbSerial_RecvData.\r\n"));    


    // call common events handler if rx in progress
    while ((pTransfer->status & USBDBG_TRANSFER_STATUS_INPROGRESS) && 
           (retryCnt++ < RECV_RETRY_COUNT))
    {
        UsbSerial_EventHandler();
    }
    
    if (pTransfer->status & USBDBG_TRANSFER_STATUS_COMPLETE)
    {
        if (cbBufSize < pTransfer->cbTransferred)
        {
            USBDBGMSG(USBDBG_ZONE_ERROR, (L"ERROR!usbdbg:UsbSerial_RecvData:"
                L"Recvd %d bytes > buffer size %d\r\n",
                pTransfer->cbTransferred, cbBufSize));
        }
        else
        {
            cbRecvdData = pTransfer->cbTransferred;
            memcpy(pbBuffer, pTransfer->pbBuffer, cbRecvdData);
        }
    }

//clean:
    // if a transfer is not in progress start next transfer
    if (!(pTransfer->status & USBDBG_TRANSFER_STATUS_INPROGRESS))
    {
        StartTransfer(epNum,
                       ENDPT_DIR_RX,
                       &m_BulkRxPktBuf[0],
                       sizeof(m_BulkRxPktBuf),
                       0);
    }

    USBDBGMSG(USBDBG_ZONE_FUNC, (L"usbdbg:-UsbSerial_RecvData.\r\n"));
    return cbRecvdData;
}

// Called by SerIfc to send data packets (over EP2 BULK IN)
//
DWORD
UsbSerial_SendData(
    UINT8 *pData,           /* (IN) data to send */
    UINT32 cbDataLen        /* (IN) cb of data to send */
    )
{
    return SendRecvData(BULKIN_ENDPT, ENDPT_DIR_TX, pData, cbDataLen, 0); 
}

void
UsbSerial_SetPower(
    BOOL fPowerOff
    )
{
    m_pddIfc.pfnSetPower(fPowerOff);
}

// Called by SerIfc to initialize UsbDbgSer stack
//
BOOL                        /* TRUE if success, FALSE if error */
UsbSerial_Init(
    )
{

    m_mddInterface.version = 2;

    memset(&m_pddIfc, 0, sizeof(m_pddIfc));

    // get usbdbgpdd function table
    // 
    if( UsbDbgPdd_Init(&m_mddInterface,
                       &m_pddIfc,
                       (USBDBG_DEVICE_DESCRIPTOR*) &m_deviceDesc
                       ) != ERROR_SUCCESS)
    {
        USBDBGMSG(USBDBG_ZONE_ERROR, (
            L"ERROR!usbdbg:UsbDbgPdd_Init failed!\r\n"));
        return FALSE;
    }

    // verify m_pddIfc
    //
    if ((m_pddIfc.version != 2) ||
        (!m_pddIfc.pfnDeinit) ||
        (!m_pddIfc.pfnConnect) ||
        (!m_pddIfc.pfnDisconnect) ||
        (!m_pddIfc.pfnIoctl) ||
        (!m_pddIfc.pfnEventHandler) ||
        (!m_pddIfc.pfnRecvData) ||
        (!m_pddIfc.pfnSendData) ||
        (!m_pddIfc.pfnSendCmd) ||
        (!m_pddIfc.pfnSetPower))
    {
        USBDBGMSG(USBDBG_ZONE_ERROR, (
            L"ERROR!usbdbg:Incorrect USBDBGPDD interface. UsbDbgPdd_Init "
            L"failed!\r\n"));
        return FALSE;
    }

    // get max sizes of Endpoints from PDD and store in m_pucUSBDescriptors
    //
    if (!UpdateUSBDesc())
        return FALSE;

    // kick off the attach/reset process
    //
    if (!m_pddIfc.pfnConnect((USBDBG_DEVICE_DESCRIPTOR*) &m_deviceDesc))
        return FALSE;
        
    return TRUE;
}

BOOL UsbSerial_IsConnected(
    )
{
    return m_fConnected;
}