--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/usbdrv/peripheral/pdd/pil/src/controltransfersm.cpp Fri Jul 23 15:54:47 2010 +0800
@@ -0,0 +1,604 @@
+/*
+ Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+ All rights reserved.
+
+ This program and the accompanying materials are made available
+ under the terms of the Eclipse Public License v1.0 which accompanies
+ this distribution, and is available at
+ http://www.eclipse.org/legal/epl-v10.html
+
+ Initial Contributors:
+ Nokia Corporation - initial contribution.
+
+ Contributors:
+*/
+
+#include "controltransfersm.h"
+
+// Bitmap of setup packet
+/*
+Offset 0, bmRequestType, 1 bytes
+ 1 Bit-Map
+ D7 Data Phase Transfer Direction
+ 0 = Host to Device
+ 1 = Device to Host
+
+ D6..5 Type
+ 0 = Standard
+ 1 = Class
+ 2 = Vendor
+ 3 = Reserved
+
+ D4..0 Recipient
+ 0 = Device
+ 1 = Interface
+ 2 = Endpoint
+ 3 = Other
+ 4..31 = Reserved
+
+Offset 1, bRequest
+
+Offset 6, Count, 2 bytes
+ Number of bytes to transfer if there is a data phase
+*/
+
+#if defined(_DEBUG)
+
+#define CTSM_ID "ControlTransferSM "
+
+char* DebugName[] =
+ {
+ "Setup",
+ "Data Out",
+ "Status In",
+ "Data In",
+ "Status Out"
+ };
+
+#endif
+
+// Static data instance
+TUsbcSetup TSetupPkgParser::iSetupPkt;
+
+TSetupPkgParser::TSetupPkgParser()
+ {
+ iSetupPkt.iRequestType = 0;
+ iSetupPkt.iRequest = 0;
+
+ iSetupPkt.iValue = 0;
+ iSetupPkt.iIndex = 0;
+ iSetupPkt.iLength = 0;
+ }
+
+// Code for TSetupPkgParser
+// we do a bitwise copy here.
+void TSetupPkgParser::Set(const TUint8* aSetupBuf)
+ {
+ // TUint8 index
+ iSetupPkt.iRequestType = static_cast<const TUint8*>(aSetupBuf)[0];
+ iSetupPkt.iRequest = static_cast<const TUint8*>(aSetupBuf)[1];
+ // TUint16 index from here!
+ iSetupPkt.iValue = SWAP_BYTES_16((reinterpret_cast<const TUint16*>(aSetupBuf))[1]);
+ iSetupPkt.iIndex = SWAP_BYTES_16((reinterpret_cast<const TUint16*>(aSetupBuf))[2]);
+ iSetupPkt.iLength = SWAP_BYTES_16((reinterpret_cast<const TUint16*>(aSetupBuf))[3]);
+
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "TSetupPkgParser::Set"));
+ }
+
+// return the next stage by decoding the setup packet
+// the possible stage followed by a setup packet are:
+// StatusIn (no data stage)
+// DataOut (host sent to peripheral)
+// DataIn (peripheral to host)
+UsbShai::TControlStage TSetupPkgParser::NextStage()
+ {
+ UsbShai::TControlStage ret = UsbShai::EControlTransferStageMax;
+
+ // Take the data length out, 0 length means no data stage
+ if (iSetupPkt.iLength == 0)
+ {
+ ret = UsbShai::EControlTransferStageStatusIn;
+ }
+ else if ((iSetupPkt.iRequestType & KUsbRequestType_DirMask) == KUsbRequestType_DirToDev)
+ {
+ // Dir to device means host will send data out
+ ret = UsbShai::EControlTransferStageDataOut;
+ }
+ else
+ {
+ // Otherwise, there must be a datain stage follows
+ ret = UsbShai::EControlTransferStageDataIn;
+ }
+
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "TSetupPkgParser::NextStage %d", ret));
+
+ return ret;
+ }
+
+// Base class of stage sm
+TControlStageSm::TControlStageSm(DControlTransferManager& aTransferMgr):
+ iTransferMgr(aTransferMgr)
+ {
+ }
+
+void TControlStageSm::ChangeToStage(UsbShai::TControlStage aToStage)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "<> TControlStageSm::ChangeToStage: %s",DebugName[aToStage]));
+ iTransferMgr.iCurrentStage = aToStage;
+ }
+
+void TControlStageSm::ClearPendingRead()
+ {
+ iTransferMgr.iReadPending = EFalse;
+ }
+
+// Code for DControlTransferManager
+//
+
+DControlTransferManager::DControlTransferManager(MControlTransferIf& aCtrTransIf):
+ iCtrTransferIf(aCtrTransIf)
+ {
+ for(int i=0; i<UsbShai::EControlTransferStageMax; i++)
+ {
+ iState[i] = NULL;
+ }
+
+ Reset();
+ }
+
+TInt DControlTransferManager::SetupEndpointZeroRead()
+ {
+ if(iState[iCurrentStage]->IsRequstAllowed(TControlTransferRequestRead))
+ {
+ if(!iReadPending)
+ {
+ iReadPending = ETrue;
+ return CtrTransferIf().ProcessSetupEndpointZeroRead();
+ }
+ else
+ {
+ // A read operation already on going, ignore this request
+ return KErrNone;
+ }
+ }
+ else
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID " !! SetupEndpointZeroRead discard"));
+ return KErrNotReady;
+ }
+ }
+
+TInt DControlTransferManager::SetupEndpointZeroWrite(const TUint8* aBuffer, TInt aLength, TBool aZlpReqd)
+ {
+ if(iState[iCurrentStage]->IsRequstAllowed(TControlTransferRequestWrite))
+ {
+ return CtrTransferIf().ProcessSetupEndpointZeroWrite(aBuffer,aLength,aZlpReqd);
+ }
+ else
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID " !! SetupEndpointZeroWrite discard"));
+ return KErrNotReady;
+ }
+ }
+
+TInt DControlTransferManager::SendEp0ZeroByteStatusPacket()
+ {
+ if(iState[iCurrentStage]->IsRequstAllowed(TControlTransferRequestSendStatus))
+ {
+ iCurrentStage = UsbShai::EControlTransferStageSetup;
+ return CtrTransferIf().ProcessSendEp0ZeroByteStatusPacket();
+ }
+ else
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID " !! SendEp0ZeroByteStatusPacket discard"));
+ return KErrNotReady;
+ }
+ }
+
+TInt DControlTransferManager::StallEndpoint(TInt aRealEndpoint)
+ {
+ // Endpoint is stalled, we need to reset our state machine.
+ Reset();
+ return CtrTransferIf().ProcessStallEndpoint(aRealEndpoint);
+ }
+
+void DControlTransferManager::Ep0SetupPacketProceed()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID " !! Missed setup packet processed"));
+ CtrTransferIf().ProcessEp0SetupPacketProceed();
+ }
+
+void DControlTransferManager::Ep0DataPacketProceed()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID " !! Missed data packet processed"));
+ CtrTransferIf().ProcessEp0DataPacketProceed();
+ }
+
+void DControlTransferManager::Reset()
+ {
+ iCurrentStage = UsbShai::EControlTransferStageSetup;
+ iReadPending = EFalse;
+ }
+
+void DControlTransferManager::Ep0RequestComplete(TUint8* aBuf,
+ TInt aCount,
+ TInt aError,
+ UsbShai::TControlPacketType aPktType)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "> DControlTransferManager::Ep0RequestComplete, packet type: %s", DebugName[aPktType]));
+ // If a setup packet comes, update our local setup packet buffer first
+ if(aPktType == UsbShai::EControlPacketTypeSetup)
+ {
+ iPacketParser.Set(aBuf);
+ // This is the only place this variable to be reset.
+ iDataTransfered = 0;
+ }
+
+ // RequestComplete will return ETrue if it can not handle a packet
+ // And it knows that some other sm can handle it.
+ // It will update the state to the one which can hanlde that packet first.
+ TBool furtherProcessNeeded = ETrue;
+ while(furtherProcessNeeded)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(" We're at Stage: %s", DebugName[iCurrentStage]));
+ furtherProcessNeeded = iState[iCurrentStage]->RequestComplete(aCount,aError,aPktType);
+ __KTRACE_OPT(KUSB, Kern::Printf(" We're moved to stage: %s", DebugName[iCurrentStage]));
+ }
+
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "< DControlTransferManager::Ep0RequestComplete"));
+ }
+
+// setup the state machine for a state
+void DControlTransferManager::AddState(UsbShai::TControlStage aStage,TControlStageSm& aStageSm)
+ {
+ if( (aStage >= UsbShai::EControlTransferStageSetup) && (aStage < UsbShai::EControlTransferStageMax))
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID " AddState(), Stage: %s", DebugName[aStage]));
+ iState[aStage] = &aStageSm;
+ }
+ }
+
+// *************** Code for SETUP state machines **************************************
+//
+DSetupStageSm::DSetupStageSm(DControlTransferManager& aTransferMgr):
+ TControlStageSm(aTransferMgr)
+ {
+ }
+
+// WE are waiting a SETUP packet
+TBool DSetupStageSm::RequestComplete(TInt aPktSize, TInt aError, UsbShai::TControlPacketType aPktType)
+ {
+ TBool ret = EFalse;
+
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "DSetupStageSm::RequestComplete"));
+
+ if(aPktType != UsbShai::EControlPacketTypeSetup)
+ {
+ // we just discard any non-setup packet
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "ALERT: DSetupStageSm - Non-Setup recieved"));
+ return ret;
+ }
+
+ // change state to whatever returned from this call.
+ ChangeToStage(iTransferMgr.PktParser().NextStage());
+
+ // We're going to complete User's read request, consume the previous
+ // read operation
+ ClearPendingRead();
+
+ // Setup packet are always need to be processed
+ iTransferMgr.CtrTransferIf().ProcessSetupPacket(aPktSize,aError);
+
+ return EFalse;
+ }
+
+TBool DSetupStageSm::IsRequstAllowed(TControlTransferRequest aRequest)
+ {
+ // Allow user to read, No other operation is allowed
+ TBool ret = (aRequest == TControlTransferRequestRead)?ETrue:EFalse;
+
+ if( ! ret)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "Warning: request %d was blocked at DSetupStageSm",aRequest));
+ }
+
+ return ret;
+ }
+
+
+// *************** Code for DATA IN state machines **************************************
+
+DDataInStageSm::DDataInStageSm(DControlTransferManager& aTransferMgr):
+ TControlStageSm(aTransferMgr)
+ {
+ }
+
+// We are waiting for a competion of DATA IN packet
+TBool DDataInStageSm::RequestComplete(TInt aPktSize, TInt aError, UsbShai::TControlPacketType aPktType)
+ {
+ TInt completionCode = aError;
+ TBool furtherRequest = EFalse;
+
+ switch(aPktType)
+ {
+ case UsbShai::EControlPacketTypeSetup:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "ALERT: DDataInStageSm - Setup recieved"));
+ // Something goes wrong, host is abandoning the unfinished control transfer
+ completionCode = KErrGeneral;
+
+ // Force SM restart at setup stage
+ ChangeToStage(UsbShai::EControlTransferStageSetup);
+
+ // this packet is partially processed here
+ // need another SM to continue
+ furtherRequest = ETrue;
+ }
+ break;
+
+ case UsbShai::EControlPacketTypeDataIn:
+ {
+ // PSL notifing us that the data had been sent to host
+ // next step is to wait for the status from Host
+ ChangeToStage(UsbShai::EControlTransferStageStatusOut);
+
+ // In USB spec, a compete control transfer must inclue a status stage
+ // which is not case in reality,some PSL/Hardware will swallow the
+ // Status out report, so, we just complete client normally.
+ }
+ break;
+
+ default:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "ALERT: DDataInStageSm - %s recieved",DebugName[aPktType]));
+
+ // Unexpected packet will be discard, and lead us reset state machine
+ // so that we can wait for next SETUP packet.
+ // Of course error will be report to any client if any there.
+ ChangeToStage(UsbShai::EControlTransferStageSetup);
+ completionCode = KErrGeneral;
+ }
+ break;
+ }
+
+ iTransferMgr.CtrTransferIf().ProcessDataInPacket(aPktSize,completionCode);
+
+ return furtherRequest;
+ }
+
+TBool DDataInStageSm::IsRequstAllowed(TControlTransferRequest aRequest)
+ {
+ // Only write is possible because host is waiting for data from us
+ TBool ret = (aRequest == TControlTransferRequestWrite)?ETrue:EFalse;
+
+ if( ! ret)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "Warning: request %d was blocked at DDataInStageSm",aRequest));
+ }
+
+ return ret;
+ };
+
+// *************** Code for STATUS OUT state machines **************************************
+DStatusOutStageSm::DStatusOutStageSm(DControlTransferManager& aTransferMgr):
+ TControlStageSm(aTransferMgr)
+ {
+ }
+
+// We are waiting for a competion of STATUS OUT or a SETUP packet if PSL or hardware don't
+// complete a status in packet
+TBool DStatusOutStageSm::RequestComplete(TInt aPktSize, TInt aError, UsbShai::TControlPacketType aPktType)
+ {
+ TBool furtherRequest = EFalse;
+ TInt completionCode = aError;
+
+ switch(aPktType)
+ {
+ case UsbShai::EControlPacketTypeSetup:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "ALERT: DStatusOutStageSm - Setup recieved"));
+ // hw or PSL may not send back the status packet for a DATA OUT
+ // and we're ok for this, just back to EControlTransferStageSetup stage
+
+ // Force SM restart at setup stage
+ ChangeToStage(UsbShai::EControlTransferStageSetup);
+
+ // this packet is partially processed here
+ // need another SM to continue
+ furtherRequest = ETrue;
+ }
+ break;
+
+ case UsbShai::EControlPacketTypeStatusOut:
+ {
+ // Force SM restart at setup stage
+ ChangeToStage(UsbShai::EControlTransferStageSetup);
+ }
+ break;
+
+ default:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "ALERT: DStatusOutStageSm - %s recieved",DebugName[aPktType]));
+
+ // Unexpected packet will be discard, and lead us reset state machine
+ // so that we can wait for next SETUP packet.
+ // Of course error will be report to any client if any there.
+ ChangeToStage(UsbShai::EControlTransferStageSetup);
+ completionCode = KErrGeneral;
+ }
+ break;
+ }
+
+ iTransferMgr.CtrTransferIf().ProcessStatusOutPacket(completionCode);
+
+ return furtherRequest;
+
+ }
+
+TBool DStatusOutStageSm::IsRequstAllowed(TControlTransferRequest aRequest)
+ {
+ // Read is ok since client don't care the status out stage.
+ // and this lead no hurt to anybody.
+ TBool ret = (aRequest == TControlTransferRequestRead)?ETrue:EFalse;
+
+ if( ! ret)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "Warning: request %d was blocked at DStatusOutStageSm",aRequest));
+ }
+
+ return ret;
+ };
+
+// *************** Code for DATA OUT state machines **************************************
+//
+DDataOutStageSm::DDataOutStageSm(DControlTransferManager& aTransferMgr):
+ TControlStageSm(aTransferMgr)
+ {
+ }
+
+TBool DDataOutStageSm::RequestComplete(TInt aPktSize, TInt aError, UsbShai::TControlPacketType aPktType)
+ {
+ TBool furtherRequest = EFalse;
+ TInt completionCode = aError;
+
+ switch(aPktType)
+ {
+ case UsbShai::EControlPacketTypeSetup:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "ALERT: DDataOutStageSm - Setup recieved"));
+ // Host is abandon the previous Transfer
+ completionCode = KErrGeneral;
+
+ // Force SM restart at setup stage
+ ChangeToStage(UsbShai::EControlTransferStageSetup);
+
+ // this packet is partially processed here
+ // need another SM to continue
+ furtherRequest = ETrue;
+ }
+ break;
+
+ case UsbShai::EControlPacketTypeDataOut:
+ {
+ iTransferMgr.DataReceived(aPktSize);
+
+ if(!iTransferMgr.IsMoreBytesNeeded())
+ {
+ // We had recieved enough bytes as indicated by the setup
+ // packet, Data stage is finished. enter STATUS IN state
+ ChangeToStage(UsbShai::EControlTransferStageStatusIn);
+ }
+ }
+ break;
+
+ case UsbShai::EControlPacketTypeStatusIn:
+ {
+ // Status in had been sent to host
+ // return and waiting for new SETUP
+ ChangeToStage(UsbShai::EControlTransferStageSetup);
+ }
+ break;
+
+ default:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "ALERT: DDataOutStageSm - %s recieved",DebugName[aPktType]));
+
+ // Unexpected packet will be discard, and lead us reset state machine
+ // so that we can wait for next SETUP packet.
+ // Of course error will be report to any client if any there.
+ ChangeToStage(UsbShai::EControlTransferStageSetup);
+ completionCode = KErrGeneral;
+ }
+ break;
+ }
+
+ ClearPendingRead();
+ iTransferMgr.CtrTransferIf().ProcessDataOutPacket(aPktSize,completionCode);
+
+ return furtherRequest;
+ }
+
+TBool DDataOutStageSm::IsRequstAllowed(TControlTransferRequest aRequest)
+ {
+ // only read operation is allowed in data out stage.
+ TBool ret = (aRequest == TControlTransferRequestRead)?ETrue:EFalse;
+
+ if( ! ret)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "Warning: request %d was blocked at DDataOutStageSm",aRequest));
+ }
+
+ return ret;
+ };
+
+// *************** Code for DATA OUT state machines **************************************
+//
+DStatusInStageSm::DStatusInStageSm(DControlTransferManager& aTransferMgr):
+ TControlStageSm(aTransferMgr)
+ {
+ }
+
+TBool DStatusInStageSm::RequestComplete(TInt aPktSize, TInt aError, UsbShai::TControlPacketType aPktType)
+ {
+ TBool furtherRequest = EFalse;
+ TInt completionCode = KErrNone;
+
+ switch(aPktType)
+ {
+ case UsbShai::EControlPacketTypeSetup:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "ALERT: DStatusInStageSm - Setup recieved"));
+ // Status in is an optional for PSL
+ // If we received a setup packet here, we assume the previous
+ // status in packet had been successfully sent to host.
+
+ // Force SM restart at setup stage
+ ChangeToStage(UsbShai::EControlTransferStageSetup);
+
+ // this packet is partially processed here
+ // need another SM to continue
+ furtherRequest = ETrue;
+ }
+ break;
+
+ case UsbShai::EControlPacketTypeStatusIn:
+ {
+ // Status in had been recieved, monitor setup packet then.
+ ChangeToStage(UsbShai::EControlTransferStageSetup);
+ }
+ break;
+
+ default:
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "ALERT: DStatusInStageSm - %s recieved",DebugName[aPktType]));
+
+ // Unexpected packet will be discard, and lead us reset state machine
+ // so that we can wait for next SETUP packet.
+ // Of course error will be report to any client if any there.
+ ChangeToStage(UsbShai::EControlTransferStageSetup);
+ completionCode = KErrGeneral;
+ }
+ break;
+ }
+
+ iTransferMgr.CtrTransferIf().ProcessStatusInPacket(completionCode);
+
+ return furtherRequest;
+ }
+
+TBool DStatusInStageSm::IsRequstAllowed(TControlTransferRequest aRequest)
+ {
+ // Read is ok even we are wait for the client to send a zero status packet
+ TBool ret = ((aRequest == TControlTransferRequestSendStatus) ||
+ (aRequest == TControlTransferRequestRead))?ETrue:EFalse;
+
+ if( ! ret)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf(CTSM_ID "Warning: request %d was blocked at DStatusInStageSm",aRequest));
+ }
+
+ return ret;
+ }
+
+// End of file
+