diff -r 000000000000 -r a41df078684a kerneltest/e32test/usbho/t_otgdi/src/testcase0677.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/e32test/usbho/t_otgdi/src/testcase0677.cpp Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,340 @@ +// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of the License "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// @internalComponent +// +// + +#include +#include +#include // unicode builds +#include +#include +#include // RTest headder +#include "testcaseroot.h" +#include "testcasewd.h" +#include "testcase0677.h" + +#define _REPEATS (oOpenIterations*3) + + + +// the name below is used to add a pointer to our construction method to a pointer MAP in +// the class factory +_LIT(KTestCaseId,"PBASE-USB_OTGDI-0677"); +const TTestCaseFactoryReceipt CTestCase0677::iFactoryReceipt(KTestCaseId); + +CTestCase0677* CTestCase0677::NewL(TBool aHost) + { + LOG_FUNC + CTestCase0677* self = new (ELeave) CTestCase0677(aHost); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + + +CTestCase0677::CTestCase0677(TBool aHost) +: CTestCaseRoot(KTestCaseId, aHost) + { + LOG_FUNC + + } + + +/** + ConstructL +*/ +void CTestCase0677::ConstructL() + { + LOG_FUNC + iWDTimer = CTestCaseWatchdog::NewL(); + iRepeats = OPEN_REPEATS; + + BaseConstructL(); + } + + +CTestCase0677::~CTestCase0677() + { + LOG_FUNC + + Cancel(); + delete iWDTimer; + + } + + +void CTestCase0677::ExecuteTestCaseL() + { + LOG_FUNC + iCaseStep = EPreconditions; + + iRepeats = KOperationRetriesMax; // VBus event rise retries + + CActiveScheduler::Add(this); + SelfComplete(); + + } + + +void CTestCase0677::DoCancel() + { + LOG_FUNC + + // cancel our timer + iTimer.Cancel(); + } + + +void CTestCase0677::CancelKB(CTestCaseRoot *pThis) + { + LOG_FUNC + CTestCase0677 * p = REINTERPRET_CAST(CTestCase0677 *,pThis); + // cancel any pending call, and then complete our active obj with a cancel value + p->iConsole->ReadCancel(); + + } + + +void CTestCase0677::CancelNotify(CTestCaseRoot *pThis) + { + LOG_FUNC + CTestCase0677 * p = REINTERPRET_CAST(CTestCase0677 *,pThis); + // cancel any pending call, and then complete our active obj with a timeout value + switch (p->iCancelWhat) + { + case ECancelEventNotify: + p->otgCancelOtgEventRequest(); + break; + case ECancelMessageNotify: + p->otgCancelOtgMessageRequest(); + break; + case ECancelVBusNotify: + p->otgCancelOtgVbusNotification(); + break; + default: + ASSERT(0); + break; + } + p->SelfComplete(KTestCaseWatchdogTO); + } + + +// This test result depends on all the ID detection tests and the VBus driving and dropping tests have not yet passed +void CTestCase0677::DescribePreconditions() + { + test.Printf(_L("Using OET, connect oscilloscope chan.A to VBus\n")); + test.Printf(_L("Connect oscilloscope chan.B to D+\n")); + test.Printf(_L("Trigger once, 200mV, 100ms \n")); + test.Printf(_L("Prepare to observe VBus, D+ pulse.\n\n")); + } + + +void CTestCase0677::ContinueAfter(TTimeIntervalMicroSeconds32 aMicroSecs, TCaseSteps aStep) + { + LOG_VERBOSE2(_L("Wait %dms before drop VBus"), (TInt)(aMicroSecs.Int()/1000)); + iTimer.After(iStatus, aMicroSecs); + iCaseStep = aStep; + SetActive(); + } + + +// handle event completion +void CTestCase0677::RunStepL() + { + LOG_FUNC + // Obtain the completion code for this CActive obj. + TInt completionCode(iStatus.Int()); + TBuf aDescription; + TInt err(0); + + + switch(iCaseStep) + { + case EPreconditions: + iCaseStep = ELoadLdd; + if (iAutomated) + { + iCaseStep = ELoadLdd; + SelfComplete(); + break; + } + // prompt to insert connector + test.Printf(KAttachOETAsBDevice); + test.Printf(KPressAnyKeyToContinue); + RequestCharacter(); + break; + + // 1. load the LDD and init. + case ELoadLdd: + if (!StepLoadLDD()) + { + break; + } + iCaseStep = EDetectBPlug; + SelfComplete(); + break; + + // 2. detect 'B' plug now + case EDetectBPlug: + if (KTestCaseWatchdogTO == iStatus.Int()) + { + return TestFailed(KErrAbort, _L("User response too slow - FAILED!")); + } + + // if doing this test in /AUTO mode, we would fail this now + // however if we can control ID_PIN through an API in future, we turn in on now. + if (otgIdPinPresent()) + { + test.Printf(KRemoveAConnectorPrompt); + test.Printf(KPressAnyKeyToContinue); + RequestCharacter(); + + iCaseStep = EDetectBPlug; + } + else + { + iCaseStep = ERequestBus; + SelfComplete(); + } + break; + + // 5. Issue SRP (request VBUS) + case ERequestBus: + iWDTimer->Cancel(); + + test.Printf(KMsgWaitingForSRPInitiated); + otgQueueOtgEventRequest( iOTGEvent, iStatus ); + + // turn on VBus (B-SRP) + err = otgBusRequest(); + iTimeSRPStart.HomeTime(); + + if (KErrNone != err) + { + return TestFailed(KErrAbort, _L("Issue SRP - RUsbOtgDriver::BusRequest() FAILED!")); + } + iCaseStep = EWaitForSRPInitiated; + iCancelWhat = ECancelEventNotify; + iWDTimer->IssueRequest(32000*2 /*KSpec_TA_SRP_RSPNS +1000*/, this, &CancelNotify); + SetActive(); + break; + + // 6. get SRP initiated event, this is a local indication + case EWaitForSRPInitiated: + if (KTestCaseWatchdogTO == iStatus.Int()) + { + return TestFailed(KErrAbort, _L("SRP Active indication NOT fired in time - FAILED!")); + } + OtgEventString(iOTGEvent, aDescription); + test.Printf(_L("Received event %d '%S' status(%d)\n"), iOTGEvent, &aDescription, completionCode); + if (RUsbOtgDriver::EEventSrpInitiated == iOTGEvent) + { + // calc interval + TTimeIntervalMicroSeconds aIntvlMicro; + TTime aNowTime; + aNowTime.HomeTime(); + aIntvlMicro = aNowTime.MicroSecondsFrom(iTimeSRPStart); + LOG_VERBOSE2(_L("SRP active after %d ms\n"), (TInt)(aIntvlMicro.Int64()/1000)); + iCancelWhat = ECancelMessageNotify; + otgQueueOtgMessageRequest( iOTGMessage, iStatus ); + iCaseStep = EWaitForSRPTimeout; + test.Printf(KMsgWaitingForSRPTimeout); + SetActive(); + } + else + { + iCaseStep = EWaitForSRPInitiated; + test.Printf(KMsgWaitingForSRPInitiated); + iStatus = KRequestPending; + otgQueueOtgEventRequest( iOTGEvent, iStatus ); + SetActive(); + } + break; + + // 6. get SRP timeout event, this is a local indication + case EWaitForSRPTimeout: + if (KTestCaseWatchdogTO == iStatus.Int()) + { + return TestFailed(KErrAbort, _L("SRP T/O NOT fired in time - FAILED!")); + } + OtgMessageString(iOTGMessage, aDescription); + test.Printf(_L("Received message %d '%S' status(%d)\n"), iOTGMessage, &aDescription, completionCode); + if (RUsbOtgDriver::EMessageSrpTimeout == iOTGMessage) + { + iWDTimer->Cancel(); // Only cancel WD Timer here, when timed portion of test is over + // calc interval + TTimeIntervalMicroSeconds aIntvlMicro; + TTime aNowTime; + aNowTime.HomeTime(); + aIntvlMicro = aNowTime.MicroSecondsFrom(iTimeSRPStart); + LOG_VERBOSE2(_L("SRP times out after %d ms\n"), (TInt)(aIntvlMicro.Int64()/1000)); + // the correct value is 32 seconds, not 4.9 seconds as per the spec. + + iCaseStep = EIssueSRPObservedPrompt; + SelfComplete(); + } + else + { + iCaseStep = EWaitForSRPTimeout; + test.Printf(KMsgWaitingForSRPTimeout); + iStatus = KRequestPending; + otgQueueOtgMessageRequest( iOTGMessage, iStatus ); + SetActive(); + } + break; + + case EIssueSRPObservedPrompt: + { + test.Printf(_L("\nPress Y to verify that SRP was observed\n")); + test.Printf(_L("or any other key to fail test.\n")); + RequestCharacter(); + iCaseStep = ECheckSRPObservedUserInput; + break; + } + + + case ECheckSRPObservedUserInput: + { + if (('y' != iKeyCodeInput) && ('Y' != iKeyCodeInput)) + { + return TestFailed(KErrAbort, _L("SRP NOT observed - FAILED!")); + } + iCaseStep = EUnloadLdd; + SelfComplete(); + break; + } + + // 12. unload OTG + case EUnloadLdd: + if (EFalse == StepUnloadLDD()) + return TestFailed(KErrAbort,_L("Unload Ldd failure")); + + iCaseStep = ELastStep; + SelfComplete(); + break; + + case ELastStep: + TestPassed(); + break; + + default: + test.Printf(_L(" unknown test step\n")); + Cancel(); + return (TestFailed(KErrCorrupt, _L(" unknown test step"))); + } + } + +