/* * usb_test() * USB Bulk transfer test. Device is detected as an eZDSP5535 when * connected to PC while test is running. Bulk transfers can be * made using USB_55xx program. * */ CSL_Status usb_test(void) { CSL_IRQ_Config config; CSL_Status result; Uint16 eventMask; result = CSL_USB_TEST_FAILED; usbConfig.opMode = CSL_USB_OPMODE_POLLED; usbConfig.devNum = CSL_USB0; usbConfig.maxCurrent = CSL_USB_MAX_CURRENT; usbConfig.appSuspendCallBack = (CSL_USB_APP_CALLBACK)CSL_suspendCallBack; usbConfig.appWakeupCallBack = (CSL_USB_APP_CALLBACK)CSL_selfWakeupCallBack; usbConfig.startTransferCallback = CSL_startTransferCallback; usbConfig.completeTransferCallback = CSL_completeTransferCallback; hEpObjArray[0] = &usbCtrlOutEpObj; hEpObjArray[1] = &usbCtrlInEpObj; hEpObjArray[2] = &usbBulkOutEpObj; hEpObjArray[3] = &usbBulkInEpObj; /* Set the interrupt vector start address */ IRQ_setVecs((Uint32)(&VECSTART)); /* Plug the USB Isr into vector table */ config.funcAddr = &usb_isr; IRQ_plug(USB_EVENT, config.funcAddr); /* Enable USB Interrupts */ IRQ_enable(USB_EVENT); /* Enable CPU Interrupts */ IRQ_globalEnable(); /* Initialize the USB module */ status = USB_init(&usbConfig); if(status != CSL_SOK) { printf("USB init failed\n"); return(result); } /* Reset the USB device */ status = USB_resetDev(CSL_USB0); if(status != CSL_SOK) { printf("USB Reset failed\n"); return(result); } /* Initialize the Control Endpoint OUT 0 */ eventMask = (CSL_USB_EVENT_RESET | CSL_USB_EVENT_SETUP | CSL_USB_EVENT_SUSPEND | CSL_USB_EVENT_RESUME | CSL_USB_EVENT_RESET | CSL_USB_EVENT_EOT); status = USB_initEndptObj(CSL_USB0, hEpObjArray[0], CSL_USB_OUT_EP0,CSL_USB_CTRL, CSL_USB_EP0_PACKET_SIZE, eventMask, NULL); if(status != CSL_SOK) { printf("USB End point init failed\n"); return(result); } /* Initialize the Control Endpoint IN 0 */ status = USB_initEndptObj(CSL_USB0, hEpObjArray[1], CSL_USB_IN_EP0, CSL_USB_CTRL, CSL_USB_EP0_PACKET_SIZE, CSL_USB_EVENT_EOT, NULL); if(status != CSL_SOK) { printf("USB End point init failed\n"); return(result); } /* Initialize the Bulk Endpoint IN 1 */ eventMask = (CSL_USB_EVENT_RESET | CSL_USB_EVENT_EOT); status = USB_initEndptObj(CSL_USB0, hEpObjArray[2], CSL_USB_IN_EP1, CSL_USB_BULK, CSL_USB_EP1_PACKET_SIZE_FS, eventMask, NULL); if(status != CSL_SOK) { printf("USB End point init failed\n"); return(result); } /* Initialize the Bulk Endpoint OUT 2 */ status = USB_initEndptObj(CSL_USB0, hEpObjArray[3], CSL_USB_OUT_EP1, CSL_USB_BULK, CSL_USB_EP1_PACKET_SIZE_FS, CSL_USB_EVENT_EOT, NULL); if(status != CSL_SOK) { printf("USB End point init failed\n"); return(result); } /* Set the parameters */ status = USB_setParams(CSL_USB0, hEpObjArray, FALSE); if(status != CSL_SOK) { printf("USB Set params failed\n"); return(result); } /* Connect the USB device */ status = USB_connectDev(CSL_USB0); if(status != CSL_SOK) { printf("USB Connect failed\n"); return(result); } deviceDescPtr = (Uint16 *)deviceDesc; cfgDescPtr = (Uint16 *)cfgDesc; strDescPtr = (Uint16 *)strDesc; dataReadBuffPtr = (Uint16 *)dataReadBuff; dataWriteBuffPtr = (Uint16 *)dataWriteBuff; while(stopRunning != TRUE); result = CSL_USB_TEST_PASSED; return(result); }
/** * \brief Tests USB interrupt mode operation * * \param none * * \return Test result */ Int16 BoardUSB_init(void) { Uint16 eventMask; Int16 looper; CSL_UsbConfig usbConfig; usbConfig.opMode = CSL_USB_OPMODE_POLLED; usbConfig.devNum = CSL_USB0; usbConfig.maxCurrent = CSL_USB_MAX_CURRENT; usbConfig.appSuspendCallBack = (CSL_USB_APP_CALLBACK)NULL; usbConfig.appWakeupCallBack = (CSL_USB_APP_CALLBACK)NULL; usbConfig.startTransferCallback = CSL_startTransferCallback; usbConfig.completeTransferCallback = NULL; hEpObjArray[0] = &usbCtrlOutEpObj; hEpObjArray[1] = &usbCtrlInEpObj; hEpObjArray[2] = &usbBulkOutEpObj; hEpObjArray[3] = &usbBulkInEpObj; CSL_CPU_REGS->IER1 |= 0x0010; // enable USB interrupt /* Initialize the USB module */ status = USB_init(&usbConfig); // never fail /* Reset the USB device */ status = USB_resetDev(CSL_USB0); // never fail when CSL_USB0 /* Initialize the Control Endpoint OUT 0 */ eventMask = CSL_USB_EVENT_RESET | CSL_USB_EVENT_SETUP | CSL_USB_EVENT_SUSPEND | CSL_USB_EVENT_RESUME | CSL_USB_EVENT_EOT; status = USB_initEndptObj(CSL_USB0, hEpObjArray[0], CSL_USB_OUT_EP0, CSL_USB_CTRL, CSL_USB_EP0_PACKET_SIZE, eventMask, NULL); if(status != CSL_SOK) // USB End point init failed return status; /* Initialize the Control Endpoint IN 0 */ status = USB_initEndptObj(CSL_USB0, hEpObjArray[1], CSL_USB_IN_EP0, CSL_USB_CTRL, CSL_USB_EP0_PACKET_SIZE, CSL_USB_EVENT_EOT, NULL); if(status != CSL_SOK) // USB End point init failed return status; /* Initialize the Bulk Endpoint IN 1 */ eventMask = CSL_USB_EVENT_RESET | CSL_USB_EVENT_EOT; status = USB_initEndptObj(CSL_USB0, hEpObjArray[2], CSL_USB_IN_EP1, CSL_USB_BULK, CSL_USB_EP1_PACKET_SIZE_HS, eventMask, NULL); if(status != CSL_SOK) // USB End point init failed return status; /* Initialize the Bulk Endpoint OUT 2 */ eventMask = CSL_USB_EVENT_RESET | CSL_USB_EVENT_EOT; status = USB_initEndptObj(CSL_USB0, hEpObjArray[3], CSL_USB_OUT_EP2, CSL_USB_BULK, CSL_USB_EP2_PACKET_SIZE_HS, eventMask, NULL); if(status != CSL_SOK) // USB End point init failed return status; /* Set the parameters */ USB_setParams(CSL_USB0, hEpObjArray, TRUE); /* for(looper = 0; looper < CSL_USB_ENDPOINT_COUNT; looper++) { gUsbEpHandle[looper] = hEpObjArray[looper]; if(hEpObjArray[looper] == NULL) break; } */ /* Connect the USB device */ CSL_FINS(usbRegisters->FADDR_POWER, USB_FADDR_POWER_SOFTCONN, TRUE); return CSL_SOK; }
CSL_Status CSL_usbPollTest(void) { CSL_Status status; CSL_Status result; pUsbContext pContext; pUsbEpHandle hEPx; CSL_UsbBoolean txRxStatus; Uint16 bytesRem; Uint16 eventMask; Uint16 saveIndex; Uint16 endpt; pUsbEpHandle tempEpH; pContext = &gUsbContext; result = CSL_USB_TEST_FAILED; usbConfig.opMode = CSL_USB_OPMODE_POLLED; usbConfig.devNum = CSL_USB0; usbConfig.maxCurrent = CSL_USB_MAX_CURRENT; usbConfig.appSuspendCallBack = (CSL_USB_APP_CALLBACK)CSL_suspendCallBack; usbConfig.appWakeupCallBack = (CSL_USB_APP_CALLBACK)CSL_selfWakeupCallBack; usbConfig.startTransferCallback = CSL_startTransferCallback; usbConfig.completeTransferCallback = CSL_completeTransferCallback; hEpObjArray[0] = &usbCtrlOutEpObj; hEpObjArray[1] = &usbCtrlInEpObj; hEpObjArray[2] = &usbBulkOutEpObj; hEpObjArray[3] = &usbBulkInEpObj; #ifdef CSL_USB_SELFWAKEUP_TEST /* Configure SAR to generate event for self wakeup */ /* NOTE: Self Wakeup is interfaced to the STOP key of the EVM keypad */ status = CSL_configSarForSelfWakeup(); if(status != CSL_SOK) { printf("SAR Configuration failed\n"); return(result); } #endif // CSL_USB_SELFWAKEUP_TEST /* Initialize the USB module */ status = USB_init(&usbConfig); if(status != CSL_SOK) { printf("USB init failed\n"); return(result); } /* Reset the USB device */ status = USB_resetDev(CSL_USB0); if(status != CSL_SOK) { printf("USB Reset failed\n"); return(result); } /* Initialized the Control Endpoint OUT 0 */ eventMask = (CSL_USB_EVENT_RESET | CSL_USB_EVENT_SETUP | CSL_USB_EVENT_SUSPEND | CSL_USB_EVENT_RESUME | CSL_USB_EVENT_RESET | CSL_USB_EVENT_EOT); status = USB_initEndptObj(CSL_USB0, hEpObjArray[0], CSL_USB_OUT_EP0,CSL_USB_CTRL, CSL_USB_EP0_PACKET_SIZE, eventMask, NULL); if(status != CSL_SOK) { printf("USB End point init failed\n"); return(result); } /* Initialized the Control Endpoint IN 0 */ status = USB_initEndptObj(CSL_USB0, hEpObjArray[1], CSL_USB_IN_EP0, CSL_USB_CTRL, CSL_USB_EP0_PACKET_SIZE, CSL_USB_EVENT_EOT, NULL); if(status != CSL_SOK) { printf("USB End point init failed\n"); return(result); } /* Initialize the Bulk Endpoint IN 1 */ eventMask = (CSL_USB_EVENT_RESET | CSL_USB_EVENT_EOT); status = USB_initEndptObj(CSL_USB0, hEpObjArray[2], CSL_USB_IN_EP1, CSL_USB_BULK, CSL_USB_EP1_PACKET_SIZE_FS, eventMask, NULL); if(status != CSL_SOK) { printf("USB End point init failed\n"); return(result); } /* Initialize the Bulk Endpoint OUT 2 */ status = USB_initEndptObj(CSL_USB0, hEpObjArray[3], CSL_USB_OUT_EP2, CSL_USB_BULK, CSL_USB_EP2_PACKET_SIZE_FS, CSL_USB_EVENT_EOT, NULL); if(status != CSL_SOK) { printf("USB End point init failed\n"); return(result); } /* Set the parameters */ status = USB_setParams(CSL_USB0, hEpObjArray, FALSE); if(status != CSL_SOK) { printf("USB Set params failed\n"); return(result); } /* Connect the USB device */ status = USB_connectDev(CSL_USB0); if(status != CSL_SOK) { printf("USB Connect failed\n"); return(result); } deviceDescPtr = (Uint16 *)deviceDesc; cfgDescPtr = (Uint16 *)cfgDesc; strDescPtr = (Uint16 *)strDesc; selfWakeupServiced = TRUE; while(stopRunning != TRUE) { /* Read the masked interrupt status register */ pContext->dwIntSourceL = usbRegisters->INTMASKEDR1; pContext->dwIntSourceH = usbRegisters->INTMASKEDR2; /* Clear the interrupts */ if(pContext->dwIntSourceL != FALSE) { usbRegisters->INTCLRR1 = pContext->dwIntSourceL; } if(pContext->dwIntSourceH != FALSE) { usbRegisters->INTCLRR2 = pContext->dwIntSourceH; } /* Reset interrupt */ if(pContext->dwIntSourceH & CSL_USB_GBL_INT_RESET) { usbRegisters->INDEX_TESTMODE = usbRegisters->INDEX_TESTMODE & 0x00ff; if(usbBulkOutEpObj.epNum == CSL_USB_IN_EP1) { CSL_FINS(usbRegisters->INDEX_TESTMODE, USB_INDEX_TESTMODE_EPSEL, CSL_USB_EP1); CSL_FINS(usbRegisters->PERI_CSR0_INDX, USB_PERI_CSR0_INDX_RXPKTRDY, TRUE); } else { CSL_FINS(usbRegisters->INDEX_TESTMODE, USB_INDEX_TESTMODE_EPSEL, CSL_USB_EP2); CSL_FINS(usbRegisters->PERI_CSR0_INDX, USB_PERI_CSR0_INDX_RXPKTRDY, TRUE); } } /* Resume interrupt */ if(pContext->dwIntSourceH & CSL_USB_GBL_INT_RESUME) { USB_setRemoteWakeup(CSL_USB0, CSL_USB_TRUE); status = USB_issueRemoteWakeup(CSL_USB0, TRUE); /* Give 10 msecs delay before resetting resume bit */ USB_delay(CSL_USB_WAKEUP_DELAY); status = USB_issueRemoteWakeup(CSL_USB0, FALSE); if(status != CSL_SOK) { printf("USB Resume failed\n"); /////INSTRUMENTATION FOR BATCH TESTING -- Part 2 -- ///// Reseting PaSs_StAtE to 0 if error detected here. PaSs_StAtE = 0x0000; // Was intialized to 1 at declaration. ///// } } /* Check End point0 interrupts */ if(pContext->dwIntSourceL & CSL_USB_TX_RX_INT_EP0) { saveIndex = usbRegisters->INDEX_TESTMODE; CSL_FINS(usbRegisters->INDEX_TESTMODE, USB_INDEX_TESTMODE_EPSEL, CSL_USB_EP0); USB_getSetupPacket(CSL_USB0, &usbSetup, TRUE); if((usbRegisters->PERI_CSR0_INDX & CSL_USB_PERI_CSR0_INDX_RXPKTRDY_MASK) == CSL_USB_PERI_CSR0_INDX_RXPKTRDY_MASK) { /* Service the RXPKTRDY after reading the FIFO */ CSL_FINS(usbRegisters->PERI_CSR0_INDX, USB_PERI_CSR0_INDX_SERV_RXPKTRDY, TRUE); /* GET DESCRIPTOR Req */ switch(usbSetup.bRequest) { /* zero data */ case CSL_USB_SET_FEATURE: switch(usbSetup.wValue) { case CSL_USB_FEATURE_ENDPOINT_STALL: /* updated set and clear endpoint stall * to work with logical endpoint num */ endpt = (usbSetup.wIndex) & 0xFF; hEPx = USB_epNumToHandle(CSL_USB0, endpt); if(!(USB_getEndptStall(hEPx, &status))) { USB_stallEndpt(hEPx); } break; case CSL_USB_FEATURE_REMOTE_WAKEUP: if(!(USB_getRemoteWakeupStat(CSL_USB0))) { USB_setRemoteWakeup(CSL_USB0, CSL_USB_TRUE); } break; default: break; } CSL_FINS(usbRegisters->PERI_CSR0_INDX, USB_PERI_CSR0_INDX_SERV_RXPKTRDY, TRUE); CSL_FINS(usbRegisters->PERI_CSR0_INDX, USB_PERI_CSR0_INDX_DATAEND, TRUE); break; case CSL_USB_CLEAR_FEATURE: switch(usbSetup.wValue) { case CSL_USB_FEATURE_ENDPOINT_STALL: endpt = (usbSetup.wIndex) & 0xFF; hEPx = USB_epNumToHandle(CSL_USB0, endpt); if(USB_getEndptStall(hEPx, &status)) { USB_clearEndptStall(hEPx); } break; case CSL_USB_FEATURE_REMOTE_WAKEUP: if(USB_getRemoteWakeupStat(CSL_USB0)) { USB_setRemoteWakeup(CSL_USB0, CSL_USB_FALSE); } break; default: break; } break; case CSL_USB_SET_CONFIGURATION : case CSL_USB_SET_INTERFACE: endpt = (usbSetup.wIndex) & 0xFF; hEPx = USB_epNumToHandle(CSL_USB0, endpt); USB_postTransaction(hEPx, 0, NULL, CSL_USB_IOFLAG_NONE); /* DataEnd + ServicedRxPktRdy */ CSL_FINS(usbRegisters->PERI_CSR0_INDX, USB_PERI_CSR0_INDX_SERV_RXPKTRDY, TRUE); CSL_FINS(usbRegisters->PERI_CSR0_INDX, USB_PERI_CSR0_INDX_DATAEND, TRUE); break; case CSL_USB_GET_DESCRIPTOR : switch(usbSetup.wValue >> 8) { case CSL_USB_DEVICE_DESCRIPTOR_TYPE: deviceDescPtr = (Uint16 *)deviceDesc; status = USB_postTransaction(hEpObjArray[1], deviceDesc[0]&0xFF, deviceDescPtr, CSL_USB_IN_TRANSFER); break; case CSL_USB_CONFIGURATION_DESCRIPTOR_TYPE: if(usbSetup.wLength == 0x0009) { cfgDescPtr = cfgDesc; status = USB_postTransaction(hEpObjArray[1], 9, cfgDescPtr, CSL_USB_IN_TRANSFER); } else { cfgDescPtr = cfgDesc; status = USB_postTransaction(hEpObjArray[1], cfgDesc[1], cfgDescPtr, CSL_USB_IN_TRANSFER); } break; case CSL_USB_STRING_DESCRIPTOR_TYPE: if((usbSetup.wValue & 0xFF) == 0x00) { strDescPtr = (Uint16 *)strDesc[0]; status = USB_postTransaction(hEpObjArray[1], strDesc[0][0]&0xFF, strDescPtr, CSL_USB_IN_TRANSFER); } if((usbSetup.wValue & 0xFF) == 0x01) { strDescPtr = (Uint16 *)strDesc[1]; status = USB_postTransaction(hEpObjArray[1], strDesc[1][0]&0xFF, strDescPtr, CSL_USB_IN_TRANSFER); } if((usbSetup.wValue & 0xFF) == 0x02) { strDescPtr = (Uint16 *)strDesc[2]; status = USB_postTransaction(hEpObjArray[1], strDesc[2][0]&0xFF, strDescPtr, CSL_USB_IN_TRANSFER); } if((usbSetup.wValue & 0xFF) == 0x03) { strDescPtr = (Uint16 *)strDesc[3]; status = USB_postTransaction(hEpObjArray[1], strDesc[3][0]&0xFF, strDescPtr, CSL_USB_IN_TRANSFER); } break; default: break; } deviceDescPtr = (Uint16 *)deviceDesc; cfgDescPtr = (Uint16 *)cfgDesc; strDescPtr = (Uint16 *)strDesc[0]; CSL_FINS(usbRegisters->PERI_CSR0_INDX, USB_PERI_CSR0_INDX_TXPKTRDY, TRUE); CSL_FINS(usbRegisters->PERI_CSR0_INDX, USB_PERI_CSR0_INDX_DATAEND, TRUE); break; case CSL_USB_SET_ADDRESS : devAddr = usbSetup.wValue; CSL_FINS(usbRegisters->PERI_CSR0_INDX, USB_PERI_CSR0_INDX_SERV_RXPKTRDY, TRUE); CSL_FINS(usbRegisters->PERI_CSR0_INDX, USB_PERI_CSR0_INDX_DATAEND, TRUE); break; default: break; } } else { if(usbSetup.bRequest == 0x05)
/** ============================================================================ * @n@b CDC_Setup * * @b Description * @n This function used to setup the Cdc and Ctrl handles. This is an internal * function and is called from CDC_Open or CDC_OpenFullspeed functions. * * @b Arguments * @verbatim pAppClassHandle Application handle to the CDC Class Obj usbSpeedCfg USB speed selection parameter 0 - USB CDC operates in fullspeed mode 1 - USB CDC operates in highspeed mode @endverbatim * * <b> Return Value </b> CSL_Status * @li CSL_SOK - Returned for success * @li CSL_ESYS_BADHANDLE - Invalid Cdc handle * * <b> Pre Condition </b> * @n None * * <b> Post Condition </b> * @n Initializes Cdc and Ctrl handles * * @b Modifies * @n Cdc and Ctrl handle data * * @b Example * @verbatim CSL_CdcInitStructApp cdcAppHandle; pCdcAppClassHandle pAppClassHandle; Uint16 cdcAppBuffer[420]; CSL_Status status; pAppClassHandle = &cdcAppHandle; // Assign values to all the members in cdcAppHandle struct cdcAppHandle.pCdcObj = &cdcAppBuffer[0]; ..... ..... // Setup USB for highspeed status = CDC_Setup(pAppClassHandle, TRUE); @endverbatim * ============================================================================ */ static CSL_Status CDC_Setup(pCdcAppClassHandle pAppClassHandle, Bool usbSpeedCfg) { pCdcClassHandle pHandle; CSL_Status status; Uint16 eventMask; Uint16 maxPktSize; status = CSL_SOK; pHandle = (pCdcClassHandle)(pAppClassHandle->pCdcObj); if(pAppClassHandle != NULL) { pHandle->ctrlHandle.devNum = CSL_USB0; /* Initializing all default values */ pHandle->ctrlHandle.suspendFlag = 0; pHandle->ctrlHandle.curConfigStat = 0x0; /* hEpObjArray needs to be setup */ pHandle->ctrlHandle.hEpObjArray[0] = &pHandle->ctrlHandle.ctrlOutEpObj; pHandle->ctrlHandle.hEpObjArray[1] = &pHandle->ctrlHandle.ctrlInEpObj; pHandle->ctrlHandle.hEpObjArray[2] = &pHandle->cdcHandle.bulkOutEpObj; pHandle->ctrlHandle.hEpObjArray[3] = &pHandle->cdcHandle.bulkInEpObj; pHandle->ctrlHandle.hEpObjArray[4] = &pHandle->cdcHandle.intrOutEpObj; pHandle->ctrlHandle.hEpObjArray[5] = &pHandle->cdcHandle.intrInEpObj; pHandle->ctrlHandle.usbSpeedCfg = usbSpeedCfg; /* Initialized the Control Endpoint OUT 0 */ eventMask = (CSL_USB_EVENT_RESET | CSL_USB_EVENT_SETUP | CSL_USB_EVENT_SUSPEND | CSL_USB_EVENT_RESUME | CSL_USB_EVENT_RESET | CSL_USB_EVENT_EOT); if(usbSpeedCfg == TRUE) { maxPktSize = CSL_USB_EP1_PACKET_SIZE_HS; } else { maxPktSize = CSL_USB_EP1_PACKET_SIZE_FS; } status = USB_initEndptObj(pHandle->ctrlHandle.devNum, &pHandle->ctrlHandle.ctrlOutEpObj, CSL_USB_OUT_EP0, CSL_USB_CTRL, CSL_USB_EP0_PACKET_SIZE, eventMask, pAppClassHandle->ctrlHandler); if(status != CSL_SOK) { return (status); } /* Initialized the Control Endpoint IN 0 */ status = USB_initEndptObj(pHandle->ctrlHandle.devNum, &pHandle->ctrlHandle.ctrlInEpObj, CSL_USB_IN_EP0, CSL_USB_CTRL, CSL_USB_EP0_PACKET_SIZE, CSL_USB_EVENT_EOT, pAppClassHandle->ctrlHandler); if(status != CSL_SOK) { return (status); } /* Initialized the Interrupt Endpoint OUT */ eventMask = (CSL_USB_EVENT_RESET | CSL_USB_EVENT_EOT); status = USB_initEndptObj(pHandle->ctrlHandle.devNum, &pHandle->cdcHandle.intrInEpObj, (CSL_UsbEpNum)(CSL_CDC_INTR_IN_EP+CSL_USB_IN_EP0), CSL_USB_INTR, maxPktSize, eventMask, pAppClassHandle->intrHandler); if(status != CSL_SOK) { return (status); } /* Initialized the Bulk Endpoint OUT */ status = USB_initEndptObj(pHandle->ctrlHandle.devNum, &pHandle->cdcHandle.bulkOutEpObj, (CSL_UsbEpNum)CSL_CDC_BULK_OUT_EP, CSL_USB_BULK, maxPktSize, CSL_USB_EVENT_EOT, pAppClassHandle->bulkHandler); if(status != CSL_SOK) { return (status); } /* Initialized the Bulk Endpoint IN */ eventMask = (CSL_USB_EVENT_RESET | CSL_USB_EVENT_EOT); status = USB_initEndptObj(pHandle->ctrlHandle.devNum, &pHandle->cdcHandle.bulkInEpObj, (CSL_UsbEpNum)(CSL_CDC_BULK_IN_EP+CSL_USB_IN_EP0), CSL_USB_BULK, maxPktSize, eventMask, pAppClassHandle->bulkHandler); if(status != CSL_SOK) { return (status); } /* USB API setParams called for setup */ status = USB_setParams(CSL_USB0, pHandle->ctrlHandle.hEpObjArray, 0); if(status != CSL_SOK) { return (status); } if(status == CSL_SOK) { /* Media Access Success; Connect the Device */ USB_connectDev(pHandle->ctrlHandle.devNum); } } else { status = CSL_ESYS_BADHANDLE; } return(status); }