--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/usbmgmt/usbmgr/host/fdf/test/t_fdf/FdfTest.cpp Tue Feb 02 02:02:59 2010 +0200
@@ -0,0 +1,391 @@
+/*
+* 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 "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:
+*
+*/
+
+#include "fdftest.h"
+#include "testmanager.h"
+#include <usb/usblogger.h>
+#include <e32cmn.h>
+
+#include <d32usbdi_hubdriver.h>
+
+#ifdef __FLOG_ACTIVE
+_LIT8(KLogComponent, "fdftest ");
+#endif
+//--------------------------------
+
+CActiveNotifyDeviceEvent::CActiveNotifyDeviceEvent(RUsbHostStack& aUsbHostStack,
+ MNotifyDeviceEventObserver& aObserver,
+ TDeviceEventInformation& aDeviceEventInformation)
+: CActive(CActive::EPriorityStandard),
+ iUsbHostStack(aUsbHostStack),
+ iObserver(aObserver),
+ iDeviceEventInformation(aDeviceEventInformation)
+ {
+ CActiveScheduler::Add(this);
+ }
+
+CActiveNotifyDeviceEvent::~CActiveNotifyDeviceEvent()
+ {
+ Cancel();
+ }
+
+CActiveNotifyDeviceEvent* CActiveNotifyDeviceEvent::NewL(RUsbHostStack& aUsbHostStack,
+ MNotifyDeviceEventObserver& aObserver,
+ TDeviceEventInformation& aDeviceEventInformation)
+ {
+ CActiveNotifyDeviceEvent* self = new(ELeave) CActiveNotifyDeviceEvent(aUsbHostStack,
+ aObserver,
+ aDeviceEventInformation);
+ return self;
+ }
+
+void CActiveNotifyDeviceEvent::Post()
+ {
+ iUsbHostStack.NotifyDeviceEvent(iStatus, iDeviceEventInformation);
+ SetActive();
+ }
+
+void CActiveNotifyDeviceEvent::RunL()
+ {
+ iObserver.MndeoDeviceEvent();
+
+ // We don't want to get into an infinite loop if the FDF dies.
+ if ( iStatus.Int() != KErrServerTerminated )
+ {
+ Post();
+ }
+ }
+
+void CActiveNotifyDeviceEvent::DoCancel()
+ {
+ iUsbHostStack.NotifyDeviceEventCancel();
+ }
+
+//--------------------------------
+
+CActiveNotifyDevmonEvent::CActiveNotifyDevmonEvent(RUsbHostStack& aUsbHostStack,
+ MNotifyDevmonEventObserver& aObserver,
+ TInt& aEvent)
+: CActive(CActive::EPriorityStandard),
+ iUsbHostStack(aUsbHostStack),
+ iObserver(aObserver),
+ iEvent(aEvent)
+ {
+ CActiveScheduler::Add(this);
+ }
+
+CActiveNotifyDevmonEvent::~CActiveNotifyDevmonEvent()
+ {
+ Cancel();
+ }
+
+CActiveNotifyDevmonEvent* CActiveNotifyDevmonEvent::NewL(RUsbHostStack& aUsbHostStack,
+ MNotifyDevmonEventObserver& aObserver,
+ TInt& aEvent)
+ {
+ CActiveNotifyDevmonEvent* self = new(ELeave) CActiveNotifyDevmonEvent(aUsbHostStack,
+ aObserver,
+ aEvent);
+ return self;
+ }
+
+void CActiveNotifyDevmonEvent::Post()
+ {
+ iUsbHostStack.NotifyDevmonEvent(iStatus, iEvent);
+ SetActive();
+ }
+
+void CActiveNotifyDevmonEvent::RunL()
+ {
+ iObserver.MndeoDevmonEvent();
+
+ // We don't want to get into an infinite loop if the FDF dies.
+ if ( iStatus.Int() != KErrServerTerminated )
+ {
+ Post();
+ }
+ }
+
+void CActiveNotifyDevmonEvent::DoCancel()
+ {
+ iUsbHostStack.NotifyDevmonEventCancel();
+ }
+
+//--------------------------------
+
+CFdfTest::CFdfTest(MTestManager& aManager)
+ : CTestBase(aManager)
+ {
+ }
+
+CTestBase* CFdfTest::NewL(MTestManager& aManager)
+ {
+ CFdfTest* self = new(ELeave) CFdfTest(aManager);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+void CFdfTest::ConstructL()
+ {
+ iNotifyDeviceEvent = CActiveNotifyDeviceEvent::NewL(iUsbHostStack,
+ *this,
+ iDeviceEventInformation);
+ iNotifyDevmonEvent = CActiveNotifyDevmonEvent::NewL(iUsbHostStack,
+ *this,
+ iDevmonEvent);
+ }
+
+CFdfTest::~CFdfTest()
+ {
+ iManager.Write(_L8("CFdfTest::~CFdfTest"));
+
+ delete iNotifyDeviceEvent;
+ delete iNotifyDevmonEvent;
+ iOtgDriver.Close();
+ iUsbHostStack.Close();
+ }
+
+void CFdfTest::ProcessKeyL(TKeyCode aKeyCode)
+ {
+ iManager.Write(_L8("CFdfTest::ProcessKeyL"));
+
+ switch ( aKeyCode )
+ {
+ case '0':
+ {
+ if ( iUsbHostStack.Handle() )
+ {
+ iManager.Write(_L8("\talready connected"));
+ }
+ else
+ {
+
+ iManager.Write(_L8("About to open LDD"));
+ _LIT(KUsbOtgLDDName,"otgdi");
+ TInt err = User::LoadLogicalDevice(KUsbOtgLDDName);
+ if ( (err != KErrNone) && (err != KErrAlreadyExists) )
+ {
+ iManager.Write(_L8("Error %d: Unable to load driver: %S"), err, &KUsbOtgLDDName);
+ LEAVEIFERRORL(err);
+ }
+
+ iManager.Write(_L8("About to open RUsbOtgDriver"));
+ err = iOtgDriver.Open();
+ if (err != KErrNone && err != KErrAlreadyExists)
+ {
+ iManager.Write(_L8("Error %d: Unable to open RUsbOtgDriver session"), err);
+ LEAVEIFERRORL(err);
+ }
+
+ iManager.Write(_L8("About to start OTG stacks"));
+ TInt iLastError = iOtgDriver.StartStacks();
+ if (iLastError != KErrNone)
+ {
+ iManager.Write(_L8("Error %d: Unable to open start OTG stacks"), iLastError);
+ LEAVEIFERRORL(err);
+ }
+
+ TInt errorBus = iOtgDriver.BusRequest();
+ iManager.Write(_L8("Error %d: iOtgDriver.BusRequest()"), errorBus);
+ if (errorBus == KErrNone)
+ {
+ iBusRequested = 1;
+ }
+
+
+ TInt error = iUsbHostStack.Connect();
+ iManager.Write(_L8("\terror = %d"), error);
+ if ( !error )
+ {
+ iManager.Write(_L8("\t Post() to wait for event "));
+ iNotifyDeviceEvent->Post();
+ iNotifyDevmonEvent->Post();
+ iManager.Write(_L8("\t After Post() to wait for event "));
+ }
+ }
+ }
+ break;
+
+ case '1':
+ {
+ TInt err = iUsbHostStack.EnableDriverLoading();
+ iManager.Write(_L8("\terr = %d"), err);
+ }
+ break;
+
+ case '2':
+ iUsbHostStack.DisableDriverLoading();
+ break;
+
+ case '3':
+ iNotifyDeviceEvent->Cancel();
+ iNotifyDevmonEvent->Cancel();
+ iUsbHostStack.Close();
+ break;
+ case '4':
+ if(iBusRequested)
+ {
+ iManager.Write(_L8("Call BusDrop()"));
+ TInt err = iOtgDriver.BusDrop();
+ iManager.Write(_L8("Call BusDrop() err = %d "),err);
+ }
+ else
+ {
+ iManager.Write(_L8("Cannot Call BusDrop() as the bus has not been Requested()"));
+ }
+ break;
+
+ default:
+ iManager.Write(_L8("Unknown selection"));
+ break;
+ }
+ }
+
+void CFdfTest::DisplayTestSpecificMenu()
+ {
+ iManager.Write(_L8("0 - RUsbHostStack::Connect"));
+ iManager.Write(_L8("1 - RUsbHostStack::EnableDriverLoading"));
+ iManager.Write(_L8("2 - RUsbHostStack::DisableDriverLoading"));
+ iManager.Write(_L8("3 - RUsbHostStack::Close"));
+ iManager.Write(_L8("4 - RUsbHostStack::StopBus"));
+
+ }
+
+void CFdfTest::MndeoDeviceEvent()
+ {
+ iManager.Write(_L8("CFdfTest::MndeoDeviceEvent"));
+ iManager.Write(KNullDesC8());
+ iManager.Write(_L8("CFdfTest::MndeoDeviceEvent"));
+
+ // Apologies for the squashed-up output this gives, but this text is no
+ // good if it scrolls off the top of the target board's screen.
+ iManager.Write(_L8("Raw data:"));
+ iManager.Write(_L8("device ID = %d, event type = %d, error = %d, driver load status = %d, vid = 0x%04x, pid = 0x%04x"),
+ iDeviceEventInformation.iDeviceId,
+ iDeviceEventInformation.iEventType,
+ iDeviceEventInformation.iError,
+ iDeviceEventInformation.iDriverLoadStatus,
+ iDeviceEventInformation.iVid,
+ iDeviceEventInformation.iPid);
+
+ iManager.Write(_L8("Interpretation:"));
+
+ _LIT8(KAttachment, "Attachment");
+ _LIT8(KDriverLoad, "Driver load");
+ _LIT8(KDetachment, "Detachment");
+ TFixedArray<const TDesC8*, 3> eventType;
+ eventType[EDeviceAttachment] = &KAttachment();
+ eventType[EDriverLoad] = &KDriverLoad();
+ eventType[EDeviceDetachment] = &KDetachment();
+
+ _LIT8(KSuccess, "Success");
+ _LIT8(KPartialSuccess, "Partial success");
+ _LIT8(KFailure, "Failure");
+ TFixedArray<const TDesC8*, 3> driverLoadStatus;
+ driverLoadStatus[EDriverLoadSuccess] = &KSuccess();
+ driverLoadStatus[EDriverLoadPartialSuccess] = &KPartialSuccess();
+ driverLoadStatus[EDriverLoadFailure] = &KFailure();
+
+ switch ( iDeviceEventInformation.iEventType )
+ {
+ case EDeviceAttachment:
+ {
+ iManager.Write(_L8("%S | device %d | error %d"),
+ eventType[iDeviceEventInformation.iEventType],
+ iDeviceEventInformation.iDeviceId,
+ iDeviceEventInformation.iError);
+ }
+ break;
+ case EDriverLoad:
+ iManager.Write(_L8("%S | device %d | %S | error %d"),
+ eventType[iDeviceEventInformation.iEventType],
+ iDeviceEventInformation.iDeviceId,
+ driverLoadStatus[iDeviceEventInformation.iDriverLoadStatus],
+ iDeviceEventInformation.iError);
+ break;
+ case EDeviceDetachment:
+ iManager.Write(_L8("%S | device %d"),
+ eventType[iDeviceEventInformation.iEventType],
+ iDeviceEventInformation.iDeviceId);
+ break;
+ default:
+ iManager.Write(_L8("INVALID iEventType"));
+ return;
+ }
+
+ if ( iDeviceEventInformation.iEventType == EDeviceAttachment && iDeviceEventInformation.iError == KErrNone )
+ {
+ iManager.Write(_L8("VID: 0x%04x, PID: 0x%04x"),
+ iDeviceEventInformation.iVid,
+ iDeviceEventInformation.iPid);
+
+ RArray<TUint> langIds;
+ TInt err = iUsbHostStack.GetSupportedLanguages(iDeviceEventInformation.iDeviceId, langIds);
+ if ( err == KErrNone )
+ {
+ const TUint count = langIds.Count();
+ iManager.Write(_L8("there is/are %d supported language(s)"), count);
+ for ( TUint ii = 0 ; ii < count ; ++ii )
+ {
+ iManager.Write(_L8("using langid %d (index %d)"), langIds[ii], ii);
+
+ TName string;
+
+ TInt err = iUsbHostStack.GetManufacturerStringDescriptor(iDeviceEventInformation.iDeviceId, langIds[ii], string);
+ if ( err == KErrNone )
+ {
+ TBuf8<256> buf;
+ buf.Copy(string);
+ iManager.Write(_L8("manufacturer string descriptor = \"%S\""), &buf);
+ }
+ else
+ {
+ iManager.Write(_L8("GetManufacturerStringDescriptor returned %d"), err);
+ }
+
+ err = iUsbHostStack.GetProductStringDescriptor(iDeviceEventInformation.iDeviceId, langIds[ii], string);
+ if ( err == KErrNone )
+ {
+ TBuf8<256> buf;
+ buf.Copy(string);
+ iManager.Write(_L8("product string descriptor = \"%S\""), &buf);
+ }
+ else
+ {
+ iManager.Write(_L8("GetProductStringDescriptor returned %d"), err);
+ }
+ }
+ }
+ else
+ {
+ iManager.Write(_L8("GetSupportedLanguages returned %d"), err);
+ }
+ langIds.Close();
+
+ }
+ }
+
+void CFdfTest::MndeoDevmonEvent()
+ {
+ iManager.Write(_L8("CFdfTest::MndeoDevmonEvent"));
+ iManager.Write(KNullDesC8());
+ iManager.Write(_L8("CFdfTest::MndeoDevmonEvent"));
+
+ iManager.Write(_L8("\tdevmon event: %d"), iDevmonEvent);
+ }