void USBSerialStream::BulkIn(U8 bEP, U8 bEPStatus) { static bool bLastWasFull = false; instance()->TransferData(false); return; USBHwEPWrite(bEP, (U8*)"a", 1); return; if (instance()->m_infifo.size() > 0) { int datatoWrite = instance()->m_infifo.size(); if (datatoWrite >= MAX_PACKET_SIZE) { bLastWasFull = true; datatoWrite = MAX_PACKET_SIZE; } else { bLastWasFull = false; } instance()->m_infifo.pop(dataBuf, datatoWrite); USBHwEPWrite(bEP, dataBuf, datatoWrite); } else if (bLastWasFull) { // I think we need to transmit a zero length package in this case. USBHwEPWrite(bEP, dataBuf, 0); } }
/** Handles the BOT bulk IN endpoint @param [in] bEP Endpoint number @param [in] bEPStatus Endpoint status (indicates NAK, STALL, etc) */ void MSCBotBulkIn(U8 bEP, U8 bEPStatus) { // ignore events on stalled EP if (bEPStatus & EP_STATUS_STALLED) { return; } switch (eState) { case eCBW: case eDataOut: // ignore possibly old ACKs break; case eDataIn: HandleDataIn(); break; case eCSW: // wait for an IN token, then send the CSW USBHwEPWrite(MSC_BULK_IN_EP, (U8 *)&CSW, 13); eState = eCBW; break; case eStalled: // keep stalling USBHwEPStall(MSC_BULK_IN_EP, TRUE); break; default: DBG("Invalid state %d\n", eState); ASSERT(FALSE); break; } }
/************************************************************************* HandleDataIn ============ Handles data from device-to-host **************************************************************************/ static void HandleDataIn(void) { int iChunk; // process data for host in SCSI layer pbData = SCSIHandleData(CBW.CBWCB, CBW.bCBWCBLength, pbData, dwOffset); if (pbData == NULL) { BOTStall(); SendCSW(STATUS_FAILED); return; } // send data to host? if (dwOffset < dwTransferSize) { iChunk = MIN(64, dwTransferSize - dwOffset); USBHwEPWrite(MSC_BULK_IN_EP, pbData, iChunk); dwOffset += iChunk; } // are we done now? if (dwOffset == dwTransferSize) { if (dwOffset != CBW.dwCBWDataTransferLength) { // stall pipe DBG("stalling DIN"); BOTStall(); } // done SendCSW(STATUS_PASSED); } }
void USBSerialStream::TransferData(bool bInit) { // We'll end up here both if we come from the frame handler, and the bulkin handler if (bInit) { m_bTransferInProgress = true; m_bDontStartNew = true; } if (!m_bTransferInProgress) { return; } int dataToSend = m_infifo.size(); if (dataToSend >= MAX_PACKET_SIZE) { dataToSend = MAX_PACKET_SIZE; } else { m_bTransferInProgress = false; m_bDontStartNew = false; } instance()->m_infifo.pop(dataBuf, dataToSend); USBHwEPWrite(BULK_IN_EP, dataBuf, dataToSend); }
/** Local function to handle outgoing bulk data @param [in] bEP @param [in] bEPStatus */ static void BulkIn(unsigned char bEP, unsigned char bEPStatus) { int i, iLen; long lHigherPriorityTaskWoken = pdFALSE; ( void ) bEPStatus; if (uxQueueMessagesWaitingFromISR( xCharsForTx ) == 0) { // no more data, disable further NAK interrupts until next USB frame USBHwNakIntEnable(0); return; } // get bytes from transmit FIFO into intermediate buffer for (i = 0; i < MAX_PACKET_SIZE; i++) { if( xQueueReceiveFromISR( xCharsForTx, ( &abBulkBuf[i] ), &lHigherPriorityTaskWoken ) != pdPASS ) { break; } } iLen = i; // send over USB if (iLen > 0) { USBHwEPWrite(bEP, abBulkBuf, iLen); } portEND_SWITCHING_ISR( lHigherPriorityTaskWoken ); }
/** Local function to handle outgoing bulk data @param [in] bEP @param [in] bEPStatus */ static void BulkIn(U8 bEP, U8 bEPStatus) { int i, iLen; // Verifica se não há data para enviar ao PC if (_fifo_avail(&txfifo) == 0) { // no more data, disable further NAK interrupts until next USB frame USBHwNakIntEnable(0); // não é gerada nenhuma interrupção sempre que o host tenta ler/escrever nos EPs mas este estão cheios/vazios. return; } // get bytes from transmit FIFO into intermediate buffer for (i = 0; i < MAX_PACKET_SIZE; i++) { if (!_fifo_get(&txfifo, &abBulkBuf[i])) { break; // sai do ciclo quando o fifo fica vazio, terminando a transferência de informação do &txfifo para &abBulkBuf[]. } } iLen = i; // send over USB if (iLen > 0) { USBHwEPWrite(bEP, abBulkBuf, iLen); } }
/** Local function to handle outgoing bulk data @param [in] bEP @param [in] bEPStatus */ static void BulkIn(U8 bEP, U8 bEPStatus) { int i, iLen; if (_fifo_avail(&txfifo) == 0) { // no more data, disable further NAK interrupts until next USB frame USBHwNakIntEnable(0); return; } // get bytes from transmit FIFO into intermediate buffer for (i = 0; i < MAX_PACKET_SIZE; i++) { if (!_fifo_get(&txfifo, &abBulkBuf[i])) { break; } } iLen = i; // send over USB if (iLen > 0) { USBHwEPWrite(bEP, abBulkBuf, iLen); } }
/** Sends the next packet in chain of packets to the host @param [in] bEP @param [in] bEPStatus */ static void SendNextBulkIn(uint8_t bEP, bool fFirstPacket) { int iLen; // this transfer is done fBulkInBusy = FALSE; // first packet? if (fFirstPacket) { fChainDone = FALSE; } // last packet? if (fChainDone) { return; } // get up to MAX_PACKET_SIZE bytes from transmit FIFO into intermediate buffer // for (iLen = 0; iLen < MAX_PACKET_SIZE; iLen++) { // if (!fifo_get(&txfifo, &abBulkBuf[iLen])) { // break; // } // } // send over USB USBHwEPWrite(bEP, abBulkBuf, iLen); fBulkInBusy = TRUE; // was this a short packet? if (iLen < MAX_PACKET_SIZE) { fChainDone = TRUE; } }
void USBFrameHandler(uint16_t wFrame) { // send over USB if( isConnectedFlag ) { if( delay < 4000 ) { //FIXME need to delay a few seconds before doing isoc writes, impliment more elegant solution, status or event driven.... delay++; } else { //Always write whatever is in our most recent isoc output data buffer, you may want to pust somthing interesting in there.... inputIsocDataBuffer[0]++; USBHwEPWrite(ISOC_IN_EP, inputIsocDataBuffer, BYTES_PER_ISOC_FRAME); int iLen = USBHwISOCEPRead(ISOC_OUT_EP, outputIsocDataBuffer, sizeof(outputIsocDataBuffer)); if (iLen > 0) { //Insert your code to do somthing interesting here.... //DBG("z%d", b1); //The host sample code will send a byte indicating if the BLUE LED should be on of off. if( outputIsocDataBuffer[0] ) { // BLUE_LED_ON } else { BLUE_LED_OFF; } } } } else { RED_LED_ON; } }
void USBFrameHandler(U16 wFrame) { // send over USB if( isConnectedFlag ) { if( delay < 4000 ) { delay++; } else { USBHwEPWrite(ISOC_IN_EP, inputIsocDataBuffer, BYTES_PER_ISOC_FRAME); int iLen = USBHwISOCEPRead(ISOC_OUT_EP, outputIsocDataBuffer, sizeof(outputIsocDataBuffer)); if (iLen > 0) { //FIXME parse data and control somthing U8 b1 = outputIsocDataBuffer[0]; if( b1 ) { IOSET0 |= (1<<10); } else { IOCLR0 |= (1<<10); } DBG("z%d", b1); } } } }
int dequeue_send(u32 clkn) { usb_pkt_rx *pkt = dequeue(&pkt); if (pkt != NULL) { last_usb_pkt = clkn; USBHwEPWrite(BULK_IN_EP, (u8 *)pkt, sizeof(usb_pkt_rx)); return 1; } else { if (clkn - last_usb_pkt > USB_KEEP_ALIVE) { u8 pkt_type = KEEP_ALIVE; last_usb_pkt = clkn; USBHwEPWrite(BULK_IN_EP, &pkt_type, 1); } return 0; } }
/* Local function to handle outgoing bulk data @param [in] bEP @param [in] bEPStatus */ void BulkIn(uint8_t bEP, uint8_t bEPStatus) { if(usbSendBufferSize > 0) { USBHwEPWrite(bEP, usbSendBuffer, usbSendBufferSize); deleteBulkInBuf(); } }
/** Sends next chunk of data (possibly 0 bytes) to host */ static void DataIn(void) { int iChunk; iChunk = MIN(MAX_PACKET_SIZE0, iResidue); USBHwEPWrite(0x80, pbData, iChunk); pbData += iChunk; iResidue -= iChunk; }
static void HandleFrame(U16 wFrame) { static int iCount; _iFrame++; if ((_iFrame > 1000)) { // send report (dummy data) abReport[0] = (iCount >> 8) & 0xFF; abReport[1] = (iCount) & 0xFF; iCount++; USBHwEPWrite(INTR_IN_EP, abReport, REPORT_SIZE); _iFrame = 0; }
/** Sends next chunk of data (possibly 0 bytes) to host */ static void DataIn(void) { int iChunk; if( MAX_PACKET_SIZE0 < iResidue ) { iChunk = MAX_PACKET_SIZE0; } else { iChunk = iResidue; } USBHwEPWrite(0x80, pbData, iChunk); pbData += iChunk; iResidue -= iChunk; }
/** Sends the next packet in chain of packets to the host @param [in] bEP @param [in] bEPStatus */ static void SendNextBulkIn(U8 bEP, BOOL fFirstPacket) { int iLen; // this transfer is done /* fBulkInBusy = FALSE; // first packet? if (fFirstPacket) { fChainDone = FALSE; } */ // last packet? /* if (fChainDone) { return; } */ // get up to MAX_PACKET_SIZE bytes from transmit FIFO into intermediate buffer for (iLen = 0; iLen < MAX_PACKET_SIZE_BULK; iLen++) { if (!fifo_get(&bulk_txfifo, &bulkBuf[iLen])) { break; } } // send over USB DBG("Ba %d ", iLen); USBHwEPWrite(bEP, bulkBuf, iLen); DBG("Bb"); //fBulkInBusy = TRUE; // was this a short packet? /*if (iLen < MAX_PACKET_SIZE_BULK) { fChainDone = TRUE; } */ }