/** ============================================================================ * @n@b CDC_bulkOutHandler * * @b Description * @n This function handles all the CDC ACM bulk OUT data transactions * * @b Arguments * @verbatim pContext Pointer to the USBContext structure hCdcClass Handle to the CDC Class Obj @endverbatim * * <b> Return Value </b> - Status of the processing (CSL_Status) * @li CSL_SOK (0) Success * @li CSL_ESYS_FAIL (-1) Generic failure * @li CSL_ESYS_BADHANDLE (-5) Handle passed to CSL was invalid * @li CSL_ESYS_INVPARAMS (-6) Invalid parameters * * <b> Pre Condition </b> * @n CDC module should be opened using CDC_Open/CDC_OpenFullspeed function * * <b> Post Condition </b> * @n Returns request processing status * * @b Modifies * @n None * * @b Example * @verbatim CSL_CdcInitStructApp cdcAppHandle; CSL_CdcClassStruct cdcClassStruct; CSL_Status status; // Assign values to all the members in cdcAppHandle struct cdcAppHandle.pCdcObj = &cdcClassStruct; ..... ..... status = CDC_Open(pAppClassHandle); .... .... in USB ISR: .... .... if (pContext->dwIntSourceL & (1<<(CSL_CDC_BULK_OUT_EP+CSL_USB_IN_EP0))) { // Handle the CDC BULK OUT CDC_bulkOutHandler(pContext, &CDC_AppHandle); } .... .... @endverbatim * ============================================================================ */ CSL_Status CDC_bulkOutHandler(pUsbContext pContext, CSL_CdcInitStructApp *cdcAppHandle) { pUsbEpHandle tempEpH; Uint16 tempWord, usb_income_num_bytes; CSL_Status status, txRxStatus; Uint16 bytesRem; status = CSL_SOK; // read the RX packet size // validate the RX packet first if (USB_isValidDataInFifoOut(&pContext->pEpStatus[CSL_CDC_BULK_OUT_EP])) { // get the EP2 handle tempEpH = USB_epNumToHandle(CSL_USB0, CSL_CDC_BULK_OUT_EP); usb_income_num_bytes = USB_getDataCountReadFromFifo( tempEpH ); } // make sure we have enough space to save the RX data if ((cdcAppHandle->rxEndIdx-cdcAppHandle->rxStartIdx+usb_income_num_bytes)<CSL_USB_CDC_DATA_BUF_SIZE) { if (usb_income_num_bytes==1) { status = USB_postTransaction(pContext->hEpObjArray[2], usb_income_num_bytes, &tempWord, CSL_USB_OUT_TRANSFER); if(status != CSL_SOK) { printf("USB RX Transaction failed\n"); } /* Check the transaction status */ txRxStatus = USB_isTransactionDone(pContext->hEpObjArray[2], &status); if(txRxStatus != CSL_USB_TRUE) { bytesRem = USB_bytesRemaining(pContext->hEpObjArray[2], &status); if(bytesRem) { printf("Bytes remaining: %d\n", bytesRem); } } } else { printf("USB RX multiple bytes\n"); } // copy the character read into the receiving buffer cdcAppHandle->rxBufferPtr[cdcAppHandle->rxEndIdx] = tempWord&0xFF; // increase the rxEndIdx cdcAppHandle->rxEndIdx += usb_income_num_bytes; if (cdcAppHandle->rxEndIdx>=CSL_USB_CDC_DATA_BUF_SIZE) cdcAppHandle->rxEndIdx = 0; } else { printf("USB RX Buffer is overflow\n"); } return status; }
/* * usb_isr() * USB interrupt service routine * */ interrupt void usb_isr(void) { /* 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; } if((pContext->dwIntSourceL != FALSE) || (pContext->dwIntSourceH != FALSE)) { /* 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"); } } /* 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_GET_CONFIGURATION : status = USB_postTransaction(hEpObjArray[1], 1, &curCfg, CSL_USB_IN_TRANSFER); break; case CSL_USB_SET_CONFIGURATION : curCfg = 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; 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)
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)
void usbProcessing(void) { static Bool usbDevDisconnect = TRUE; Uint16 saveIndex; Uint16 bytesRem; pUsbEpHandle tempEpH; Uint16 *strDescPtr; Uint16 endpt; CSL_UsbBoolean txRxStatus; int i; if(usbDevDisconnect == TRUE) { // wait for connecting if(CSL_FEXT(usbRegisters->DEVCTL, USB_DEVCTL_VBUS) == CSL_USB_DEVCTL_VBUS_ABOVEVBUSVALID) { usbDevDisconnect = FALSE; // connectDev CSL_FINS(usbRegisters->FADDR_POWER, USB_FADDR_POWER_SOFTCONN, TRUE); } } if((taskList & USBPROCESSING) == 0) return; /* Read the masked interrupt status register */ pContext->dwIntSourceL = usbRegisters->INTMASKEDR1; pContext->dwIntSourceH = usbRegisters->INTMASKEDR2; /* Reset interrupt */ if(pContext->dwIntSourceH & CSL_USB_GBL_INT_RESET) { usbRegisters->INDEX_TESTMODE &= 0x00ff; if(usbBulkOutEpObj.epNum == CSL_USB_IN_EP1) CSL_FINS(usbRegisters->INDEX_TESTMODE, USB_INDEX_TESTMODE_EPSEL, CSL_USB_EP1); 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) { pContext->remoteWkpStat = CSL_USB_TRUE; CSL_FINS(usbRegisters->FADDR_POWER, USB_FADDR_POWER_RESUME, TRUE); /* Give 10 msecs delay before resetting resume bit */ EZDSP5535_waitusec(10000); CSL_FINS(usbRegisters->FADDR_POWER, USB_FADDR_POWER_RESUME, FALSE); } /* 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) { /* 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(!pContext->remoteWkpStat) pContext->remoteWkpStat = 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(pContext->remoteWkpStat) pContext->remoteWkpStat = 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: status = USB_postTransaction(hEpObjArray[1], deviceDesc[0]&0xFF, deviceDesc, CSL_USB_IN_TRANSFER); break; case CSL_USB_CONFIGURATION_DESCRIPTOR_TYPE: if(usbSetup.wLength == 0x0009) status = USB_postTransaction(hEpObjArray[1], 9, cfgDesc, CSL_USB_IN_TRANSFER); else status = USB_postTransaction(hEpObjArray[1], cfgDesc[1], cfgDesc, CSL_USB_IN_TRANSFER); break; case CSL_USB_STRING_DESCRIPTOR_TYPE: i = usbSetup.wValue & 0xFF; if(i < 4) { strDescPtr = (Uint16 *)strDesc[i]; status = USB_postTransaction(hEpObjArray[1], strDesc[i][0]&0xFF, strDescPtr, CSL_USB_IN_TRANSFER); } break; default: break; } 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 {
/** ============================================================================ * @n@b CDC_bulkInHandler * * @b Description * @n This function handles all the CDC ACM bulk IN data transactions * * @b Arguments * @verbatim pContext Pointer to the USBContext structure hCdcClass Handle to the CDC Class Obj @endverbatim * * <b> Return Value </b> - Status of the processing (CSL_Status) * @li CSL_SOK (0) Success * @li CSL_ESYS_FAIL (-1) Generic failure * @li CSL_ESYS_BADHANDLE (-5) Handle passed to CSL was invalid * @li CSL_ESYS_INVPARAMS (-6) Invalid parameters * * <b> Pre Condition </b> * @n CDC module should be opened using CDC_Open/CDC_OpenFullspeed function * * <b> Post Condition </b> * @n Returns request processing status * * @b Modifies * @n None * * @b Example * @verbatim CSL_CdcInitStructApp cdcAppHandle; CSL_CdcClassStruct cdcClassStruct; CSL_Status status; // Assign values to all the members in cdcAppHandle struct cdcAppHandle.pCdcObj = &cdcClassStruct; ..... ..... status = CDC_Open(pAppClassHandle); .... .... in USB ISR: .... .... if (pContext->dwIntSourceL & (1<<CSL_CDC_BULK_IN_EP)) { // Handle the CDC BULK IN ///CDC_bulkInHandler(pContext, &CDC_AppHandle); } .... .... @endverbatim * ============================================================================ */ CSL_Status CDC_bulkInHandler(pUsbContext pContext, CSL_CdcInitStructApp *cdcAppHandle) { CSL_Status status, txRxStatus; Uint16 bytesRem, txStartIdxSave, txEndIdxSave, i; status = CSL_SOK; // Is the TX EP free? if (cdcAppHandle->txWorkBufIdx==0) { // is there anything need to send out txStartIdxSave = cdcAppHandle->txStartIdx; txEndIdxSave = cdcAppHandle->txEndIdx; if (txEndIdxSave==txStartIdxSave) { // nothing to transmit, then return return status; } else if (txEndIdxSave>txStartIdxSave) { // for no wrap around case // pack and copy the data from txBufferPtr to txWorkBufPtr for (i=0; i<(txEndIdxSave-txStartIdxSave); i++) { if (i%2) cdcAppHandle->txWorkBufPtr[i/2] = (cdcAppHandle->txBufferPtr[txStartIdxSave+i]<<8); else cdcAppHandle->txWorkBufPtr[i/2] = cdcAppHandle->txBufferPtr[txStartIdxSave+i]&0xFF; } // send whatever in the TX working buffer to host status = USB_postTransaction(pContext->hEpObjArray[3], txEndIdxSave-txStartIdxSave, cdcAppHandle->txWorkBufPtr, CSL_USB_IN_TRANSFER); if(status != CSL_SOK) { printf("USB TX Transaction failed\n"); } /* Check the transaction status */ txRxStatus = USB_isTransactionDone(pContext->hEpObjArray[3], &status); if(txRxStatus != CSL_USB_TRUE) { bytesRem = USB_bytesRemaining(pContext->hEpObjArray[3], &status); if(bytesRem) { printf("Bytes remaining: %d\n", bytesRem); } } // update the txStartIdx cdcAppHandle->txStartIdx = txEndIdxSave; } else if (txEndIdxSave<txStartIdxSave) { // for wrap around case // send the TX buffer (rxStartIdx - CSL_USB_CDC_DATA_BUF_SIZE) to host // pack and copy the data from txBufferPtr to txWorkBufPtr for (i=0; i<(CSL_USB_CDC_DATA_BUF_SIZE-txStartIdxSave); i++) { if (i%2) cdcAppHandle->txWorkBufPtr[i/2] = (cdcAppHandle->txBufferPtr[txStartIdxSave+i]<<8); else cdcAppHandle->txWorkBufPtr[i/2] = cdcAppHandle->txBufferPtr[txStartIdxSave+i]&0xFF; } // send whatever in the TX working buffer to host status = USB_postTransaction(pContext->hEpObjArray[3], CSL_USB_CDC_DATA_BUF_SIZE-txStartIdxSave, cdcAppHandle->txWorkBufPtr, CSL_USB_IN_TRANSFER); if(status != CSL_SOK) { printf("USB TX Transaction failed\n"); } /* Check the transaction status */ txRxStatus = USB_isTransactionDone(pContext->hEpObjArray[3], &status); if(txRxStatus != CSL_USB_TRUE) { bytesRem = USB_bytesRemaining(pContext->hEpObjArray[3], &status); if(bytesRem) { printf("Bytes remaining: %d\n", bytesRem); } } // update the txStartIdx cdcAppHandle->txStartIdx = 0; // send the TX buffer (0 - txEndIdx) to host // pack and copy the data from txBufferPtr to txWorkBufPtr for (i=0; i<txEndIdxSave; i++) { if (i%2) cdcAppHandle->txWorkBufPtr[i/2] = (cdcAppHandle->txBufferPtr[txStartIdxSave+i]<<8); else cdcAppHandle->txWorkBufPtr[i/2] = cdcAppHandle->txBufferPtr[txStartIdxSave+i]&0xFF; } // send whatever in the TX working buffer to host status = USB_postTransaction(pContext->hEpObjArray[3], txEndIdxSave, cdcAppHandle->txWorkBufPtr, CSL_USB_IN_TRANSFER); if(status != CSL_SOK) { printf("USB TX Transaction failed\n"); } /* Check the transaction status */ txRxStatus = USB_isTransactionDone(pContext->hEpObjArray[3], &status); if(txRxStatus != CSL_USB_TRUE) { bytesRem = USB_bytesRemaining(pContext->hEpObjArray[3], &status); if(bytesRem) { printf("Bytes remaining: %d\n", bytesRem); } } // update the txStartIdx cdcAppHandle->txStartIdx = txEndIdxSave; } } return status; }
/** ============================================================================ * @n@b CDC_eventHandler * * @b Description * @n This function handles all the CDC ACM related requests * * @b Arguments * @verbatim pContext Pointer to the USBContext structure hCdcClass Handle to the CDC Class Obj @endverbatim * * <b> Return Value </b> - Status of the request (CSL_CdcRequestRet) * @li CSL_CDC_REQUEST_DONE (0) - CDC request process done * @li CSL_CDC_REQUEST_STALL (1) - STALL the control endpoint * @li CSL_CDC_REQUEST_SEND_ACK (2) - Prepare to receive 0 length OUT packet * @li CSL_CDC_REQUEST_DATA_IN (0) - Notify handler when IN data has been transmitted * @li CSL_CDC_REQUEST_DATA_OUT (0) - Notify handler when OUT data has been received * * <b> Pre Condition </b> * @n CDC module should be opened using CDC_Open/CDC_OpenFullspeed function * * <b> Post Condition </b> * @n Returns request processing status * * @b Modifies * @n None * * @b Example * @verbatim CSL_CdcInitStructApp cdcAppHandle; CSL_CdcClassStruct cdcClassStruct; CSL_Status status; // Assign values to all the members in cdcAppHandle struct cdcAppHandle.pCdcObj = &cdcClassStruct; ..... ..... status = CDC_Open(pAppClassHandle); .... .... in USB ISR: .... .... if(pContext->dwIntSourceL & CSL_USB_TX_RX_INT_EP0) { // call USB core EP0 event handler to process USB_coreEventProcessEp0(pContext); // call the CDC event handler for further processing CDC_eventHandler(pContext, &cdcClassStruct); } .... .... @endverbatim * ============================================================================ */ CSL_CdcRequestRet CDC_eventHandler(pUsbContext pContext, CSL_CdcClassStruct *hCdcClass) { Uint16 txBuf[20], saveIndex; CSL_UsbSetupStruct usbSetup; CSL_CdcObject *pCdcObj = &hCdcClass->cdcHandle; saveIndex = usbRegisters->INDEX_TESTMODE; CSL_FINS(usbRegisters->INDEX_TESTMODE, USB_INDEX_TESTMODE_EPSEL, CSL_USB_EP0); switch ((pContext->usbSetup.bmRequestType<<8)|pContext->usbSetup.bRequest) { case CSL_CDC_REQUEST_SEND_ENCAPSULATED_COMMAND: 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_CDC_REQUEST_GET_ENCAPSULATED_RESPONSE: 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_CDC_REQUEST_SET_COMM_FEATURE: 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_CDC_REQUEST_GET_COMM_FEATURE: 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_CDC_REQUEST_CLEAR_COMM_FEATURE: 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_CDC_REQUEST_SET_LINE_CODING: 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); } // send ACK CSL_FINS(usbRegisters->PERI_CSR0_INDX, USB_PERI_CSR0_INDX_TXPKTRDY, TRUE); CSL_FINS(usbRegisters->PERI_CSR0_INDX, USB_PERI_CSR0_INDX_DATAEND, TRUE); // wait for the line coding from host while (!((usbRegisters->PERI_CSR0_INDX & CSL_USB_PERI_CSR0_INDX_RXPKTRDY_MASK) == CSL_USB_PERI_CSR0_INDX_RXPKTRDY_MASK)); // get the line coding 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); } // save it to the line coding structure pCdcObj->lineCoding.dwBaudRate = (usbSetup.bRequest<<8) | usbSetup.bmRequestType; pCdcObj->lineCoding.dwBaudRate |= ((Uint32)usbSetup.wValue<<16); pCdcObj->lineCoding.wCharFormat = usbSetup.wIndex&0xFF; pCdcObj->lineCoding.wParityType = usbSetup.wIndex>>8; pCdcObj->lineCoding.wDataBits = usbSetup.wLength&0xFF; break; case CSL_CDC_REQUEST_GET_LINE_CODING: // send the current line coding to the host // first the baud rate txBuf[0] = pCdcObj->lineCoding.dwBaudRate&0xFFFF; txBuf[1] = pCdcObj->lineCoding.dwBaudRate>>16; // second the char format and parity txBuf[2] = (pCdcObj->lineCoding.wParityType<<8) | pCdcObj->lineCoding.wCharFormat; // last the bits per character txBuf[3] = pCdcObj->lineCoding.wDataBits; USB_postTransaction(pContext->hEpObjArray[1], 7, (void*)txBuf, CSL_USB_IOFLAG_NONE | CSL_USB_IOFLAG_NOSHORT); break; case CSL_CDC_REQUEST_SET_CONTROL_LINE_STATE: // save it to control line state pCdcObj->controlLineState = pContext->usbSetup.wValue&0x03; 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_CDC_REQUEST_SEND_BREAK: 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; default: break; } usbRegisters->INDEX_TESTMODE = saveIndex; return CSL_CDC_REQUEST_DONE; }
/** ============================================================================ * @n@b CDC_putData * * @b Description * @n This function sends out the data to the BULK IN * * @b Arguments * @verbatim pContext Pointer to the USBContext structure hCdcClass Handle to the CDC Class Obj data the data to be transmitted size the data size @endverbatim * * <b> Return Value </b> - number of byte sent out * @li 0 - means the BULK IN is not ready for transmission * @li N > 0 - means the transmission is done and N byte data has been sent out * * <b> Pre Condition </b> * @n CDC module should be opened using CDC_Open/CDC_OpenFullspeed function * * <b> Post Condition </b> * @n Returns request processing status * * @b Modifies * @n None * * @b Example * @verbatim CSL_CdcInitStructApp cdcAppHandle; CSL_CdcClassStruct cdcClassStruct; CSL_Status status; Uint16 uartData[80] Uint16 uartdataSize; // Assign values to all the members in cdcAppHandle struct cdcAppHandle.pCdcObj = &cdcClassStruct; ..... ..... status = CDC_Open(pAppClassHandle); .... .... // Echo the input from the host back to the host // Get data from the host uartDataSize = CDC_getData(pContext, &CDC_AppHandle, uartData); // Echo it back, if there is an input if (uartDataSize>0) { do { // CDC_putData will return 0 if the TX is not ready for the transaction retNum = CDC_putData(pContext, &CDC_AppHandle, uartData, uartDataSize); } while (retNum==0); } .... .... @endverbatim * ============================================================================ */ Uint16 CDC_putData(pUsbContext pContext, CSL_CdcInitStructApp *cdcAppHandle, Uint16 *data, Uint16 size) { CSL_Status status, txRxStatus; Uint16 bytesRem, i; Uint16 txEndIdxSave, txStartIdxSave; // the data size cannot larger than CSL_USB_CDC_DATA_BUF_SIZE if (size>CSL_USB_CDC_DATA_BUF_SIZE) return 0; // is there anything in the TX buffer? txStartIdxSave = cdcAppHandle->txStartIdx; txEndIdxSave = cdcAppHandle->txEndIdx; if (txEndIdxSave==txStartIdxSave) { // make sure TX working buffer is free too if (cdcAppHandle->txWorkBufIdx>0) { return 0; } // copy data from data buffer to TX working buffer for (i=0; i<size; i++) { if (cdcAppHandle->txWorkBufIdx%2) { cdcAppHandle->txWorkBufPtr[cdcAppHandle->txWorkBufIdx/2] = (cdcAppHandle->txWorkBufPtr[cdcAppHandle->txWorkBufIdx/2]&0x00FF)|(data[i]<<8); } else { cdcAppHandle->txWorkBufPtr[cdcAppHandle->txWorkBufIdx/2] = (data[i]&0xFF); } // increase the txWorkBufIdx cdcAppHandle->txWorkBufIdx++; if (cdcAppHandle->txWorkBufIdx>=CSL_USB_CDC_DATA_BUF_SIZE) cdcAppHandle->txWorkBufIdx = 0; } // send it to host status = USB_postTransaction(pContext->hEpObjArray[3], size, cdcAppHandle->txWorkBufPtr, CSL_USB_IN_TRANSFER); if(status != CSL_SOK) { printf("USB TX Transaction failed\n"); } /* Check the transaction status */ txRxStatus = USB_isTransactionDone(pContext->hEpObjArray[3], &status); if(txRxStatus != CSL_USB_TRUE) { bytesRem = USB_bytesRemaining(pContext->hEpObjArray[3], &status); if(bytesRem) { printf("Bytes remaining: %d\n", bytesRem); } } // update the txStartIdx cdcAppHandle->txStartIdx = cdcAppHandle->txEndIdx; // clear the txWorkBufIdx cdcAppHandle->txWorkBufIdx = 0; } else { // TX buffer is not empty // make sure the TX has enough space for the data if (txEndIdxSave>txStartIdxSave) { if ((txEndIdxSave-txStartIdxSave+size)>CSL_USB_CDC_DATA_BUF_SIZE) return 0; } else { if ((txStartIdxSave-txEndIdxSave+size)>CSL_USB_CDC_DATA_BUF_SIZE) return 0; } // copy data from data buffer to TX buffer for (i=0; i<size; i++) { cdcAppHandle->txBufferPtr[cdcAppHandle->txEndIdx] = (cdcAppHandle->txBufferPtr[cdcAppHandle->txEndIdx/2]&0xFF00)|(data[i]&0xFF); // increase the txEndIdx cdcAppHandle->txEndIdx++; if (cdcAppHandle->txEndIdx>=CSL_USB_CDC_DATA_BUF_SIZE) cdcAppHandle->txEndIdx = 0; } } return size; }