MCL/sf/os/usb: comparison usbmgmt/usbmgrtest/t_usbmanager

equal deleted inserted replaced

-:d3e8e7d462dd
+:f92a4f87e424
 /*
-* Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 1997-2010 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".
 /**
 @file
 */
-#include "Stub1CC.h"
 #include <usb_std.h>
 #include <es_ini.h>
 #include <d32usbc.h>
-#include <usb/usblogger.h>
+#include "Stub1CC.h"
 #ifdef __FLOG_ACTIVE
 _LIT8(KLogComponent, "STUB1CC");
 #endif
 #include "usbmaninternalconstants.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "Stub1CCTraces.h"
+#endif
 // Panic category
 _LIT( Kstub1CcPanicCategory, "Usbstub1Cc" );
 *
 * @param aStatus The caller's request status, filled in with an error code
 */
 void CUsbstub1ClassController::Start(TRequestStatus& aStatus)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSTUB1CLASSCONTROLLER_START_ENTRY );
 	aStatus = KRequestPending;
 	iReportStatus = &aStatus;
 	//If we are already started then just complete the request.
 	if (iState == EUsbServiceStarted)
 		{
 		User::RequestComplete(iReportStatus, KErrNone);
+		OstTraceFunctionExit0( CUSBSTUB1CLASSCONTROLLER_START_EXIT );
 		return;
 		}
 	if (iFailToStart)
 		{
 		User::RequestComplete(iReportStatus, KErrGeneral);
+		OstTraceFunctionExit0( CUSBSTUB1CLASSCONTROLLER_START_EXIT_DUP1 );
 		return;
 		}
 	iState = EUsbServiceStarting;
 #ifndef __WINS__
 	TInt ret = iLdd.Open(0);
-	LOGTEXT2(_L8("Open LDD, ret=%d"), ret);
+	OstTrace1( TRACE_NORMAL, CUSBSTUB1CLASSCONTROLLER_START, _L8("Open LDD, ret=%d"), ret );
 	ret = SetUpInterface();
-	LOGTEXT2(_L8("SetUpInterface(), ret=%d"), ret);
+	OstTrace1( TRACE_NORMAL, CUSBSTUB1CLASSCONTROLLER_START_DUP1, _L8("SetUpInterface(), ret=%d"), ret );
 #endif
 	iTimer.After(iStatus, iStartDelay*1000);  //convert from usec to msec
 	SetActive();
+	OstTraceFunctionExit0( CUSBSTUB1CLASSCONTROLLER_START_EXIT_DUP2 );
 	}
 /**
 * Called by UsbMan when it wants to stop the USB stub1 class.
 *
 * @param aStatus The caller's request status: always set to KErrNone
 */
 void CUsbstub1ClassController::Stop(TRequestStatus& aStatus)
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSTUB1CLASSCONTROLLER_STOP_ENTRY );
 	aStatus = KRequestPending;
 	iReportStatus = &aStatus;
 	//If we are already idle then just complete the request.
 	if (iState == EUsbServiceIdle)
 		{
 		User::RequestComplete(iReportStatus, KErrNone);
+		OstTraceFunctionExit0( CUSBSTUB1CLASSCONTROLLER_STOP_EXIT );
 		return;
 		}
 	if (iFailToStop)
 		{
 		User::RequestComplete(iReportStatus, KErrGeneral);
+		OstTraceFunctionExit0( CUSBSTUB1CLASSCONTROLLER_STOP_EXIT_DUP1 );
 		return;
 		}
 	iState = EUsbServiceStopping;
 	iLdd.Close();
 #endif
 	iTimer.After(iStatus, iStopDelay*1000);  //convert from usec to msec
 	SetActive();
+	OstTraceFunctionExit0( DUP2_CUSBSTUB1CLASSCONTROLLER_STOP_EXIT );
 	}
 /**
 * Gets information about the descriptor which this class provides.
 *
 * @param aDescriptorInfo Descriptor info structure filled in by this function
 */
 void CUsbstub1ClassController::GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSTUB1CLASSCONTROLLER_GETDESCRIPTORINFO_ENTRY );
 	aDescriptorInfo.iLength = Kstub1DescriptorLength;
 	aDescriptorInfo.iNumInterfaces = Kstub1NumberOfInterfacesPerstub1Function;
+	OstTraceFunctionExit0( CUSBSTUB1CLASSCONTROLLER_GETDESCRIPTORINFO_EXIT );
 	}
 /**
 * Standard active object RunL.
 */
 void CUsbstub1ClassController::RunL()
 	{
-	LOG_FUNC
+	OstTraceFunctionEntry0( CUSBSTUB1CLASSCONTROLLER_RUNL_ENTRY );
-	__ASSERT_DEBUG( iStatus == KErrNone, _USB_PANIC(Kstub1CcPanicCategory, EPanicUnexpectedStatus) );
+	if(iStatus != KErrNone)
+	    {
+OstTrace1( TRACE_FATAL, CUSBSTUB1CLASSCONTROLLER_RUNL,
+"CUsbstub1ClassController::RunL panic with error %d",
+EPanicUnexpectedState);
+__ASSERT_DEBUG(EFalse,User::Panic(Kstub1CcPanicCategory,EPanicUnexpectedStatus));
+	    }
 	switch (iState)
 		{
 		case EUsbServiceStarting:
 			iState = EUsbServiceStarted;
 			break;
 		case EUsbServiceStopping:
 			iState = EUsbServiceIdle;
 			break;
 		default:
-			_USB_PANIC(Kstub1CcPanicCategory, EPanicUnexpectedState);
+		    OstTrace1( TRACE_FATAL, CUSBSTUB1CLASSCONTROLLER_RUNL_DUP1,
+"CUsbstub1ClassController::RunL panic with error %d",
+EPanicUnexpectedState);
+		    User::Panic(Kstub1CcPanicCategory,EPanicUnexpectedStatus);
 		}
 	*iReportStatus = KErrNone;
 	User::RequestComplete(iReportStatus, iStatus.Int());
+	OstTraceFunctionExit0( CUSBSTUB1CLASSCONTROLLER_RUNL_EXIT );
 	}
 /**
 * Standard active object cancellation function. Never called because this
 * class has no asynchronous requests.
 			break;
 		case EUsbServiceStopping:
 			iState = EUsbServiceStarted;
 			break;
 		default:
-			_USB_PANIC(Kstub1CcPanicCategory, EPanicUnexpectedState);
+		    OstTrace1( TRACE_FATAL, CUSBSTUB1CLASSCONTROLLER_DOCANCEL,
+		            "CUsbstub1ClassController::DoCancel panic with error %d", EPanicUnexpectedState );
+		    User::Panic(Kstub1CcPanicCategory,EPanicUnexpectedStatus);
 	}
 	*iReportStatus = KErrNone;
 	User::RequestComplete(iReportStatus, KErrCancel);
 	}
 * @param aError The error code (unused)
 * @return Always KErrNone to avoid an active scheduler panic
 */
 TInt CUsbstub1ClassController::RunError(TInt /*aError*/)
 	{
-	__ASSERT_DEBUG( EFalse, _USB_PANIC(Kstub1CcPanicCategory, EUnusedFunction) );
+OstTrace1( TRACE_FATAL, CUSBSTUB1CLASSCONTROLLER_RUNERROR,
+"CUsbstub1ClassController::RunError panic with error %d", EUnusedFunction);
+__ASSERT_DEBUG(EFalse,User::Panic(Kstub1CcPanicCategory,EPanicUnexpectedStatus));
 	return KErrNone;
 	}
 TInt CUsbstub1ClassController::SetUpInterface()
 /**
 * Set up the interface for use. This involves finding a "Interrupt IN"
 * endpoint and, if found, configuring the interface.
 */
 	{
-	LOGTEXT(_L8(">>CCdcControlInterface::SetUpInterface"));
+OstTrace0( TRACE_NORMAL, CUSBSTUB1CLASSCONTROLLER_SETUPINTERFACE,
+_L8(">>CCdcControlInterface::SetUpInterface"));
 	TUsbDeviceCaps dCaps;
 	TInt ret = iLdd.DeviceCaps(dCaps);
-	LOGTEXT(_L8("\tchecking result of DeviceCaps"));
+	OstTrace0( TRACE_NORMAL, CUSBSTUB1CLASSCONTROLLER_SETUPINTERFACE_DUP1,
+	        _L8("\tchecking result of DeviceCaps"));
 	if ( ret )
 		{
-		LOGTEXT2(_L8("<<CCdcControlInterface::SetUpInterface ret=%d"), ret);
+OstTrace1( TRACE_ERROR, CUSBSTUB1CLASSCONTROLLER_SETUPINTERFACE_DUP2,
+_L8("<<CCdcControlInterface::SetUpInterface ret=%d"), ret );
 		return ret;
 		}
 	const TUint KRequiredNumberOfEndpoints = 1; // in addition to endpoint 0.
 	const TUint totalEndpoints = static_cast<TUint>(dCaps().iTotalEndpoints);
-	LOGTEXT2(_L8("\tiTotalEndpoints = %d"), totalEndpoints);
+	OstTrace1( TRACE_NORMAL, CUSBSTUB1CLASSCONTROLLER_SETUPINTERFACE_DUP3,
+	        _L8("\tiTotalEndpoints = %d"), totalEndpoints);
 	if ( totalEndpoints < KRequiredNumberOfEndpoints )
 		{
-		LOGTEXT2(_L8("<<CCdcControlInterface::SetUpInterface ret=%d"),
+OstTrace1( TRACE_ERROR, CUSBSTUB1CLASSCONTROLLER_SETUPINTERFACE_DUP4,
-			KErrGeneral);
+_L8("<<CCdcControlInterface::SetUpInterface ret=%d"), KErrGeneral );
 		return KErrGeneral;
 		}
 	// Endpoints
 	TUsbcEndpointData data[KUsbcMaxEndpoints];
 	TPtr8 dataptr(reinterpret_cast<TUint8*>(data), sizeof(data), sizeof(data));
 	ret = iLdd.EndpointCaps(dataptr);
-	LOGTEXT(_L8("\tchecking result of EndpointCaps"));
+	OstTrace0( TRACE_NORMAL, CUSBSTUB1CLASSCONTROLLER_SETUPINTERFACE_DUP5,
+	        _L8("\tchecking result of EndpointCaps"));
 	if ( ret )
 		{
-		LOGTEXT2(_L8("<<CCdcControlInterface::SetUpInterface ret=%d"), ret);
+OstTrace1( TRACE_ERROR, CUSBSTUB1CLASSCONTROLLER_SETUPINTERFACE_DUP6,
+_L8("<<CCdcControlInterface::SetUpInterface ret=%d"), ret );
 		return ret;
 		}
 	// Set the active interface
 	TUsbcInterfaceInfoBuf ifc;
 	TBool epFound = EFalse;
 	for ( TUint i = 0 ; i < totalEndpoints ; i++ )
 		{
 		const TUsbcEndpointCaps* caps = &data[i].iCaps;
-		__ASSERT_DEBUG(caps,_USB_PANIC(Kstub1CcPanicCategory, EPanicUnexpectedStatus));
+		if(!caps)
+		    {
+OstTrace1( TRACE_FATAL, CUSBSTUB1CLASSCONTROLLER_SETUPINTERFACE_DUP7,
+"CUsbstub1ClassController::SetUpInterface panic with error %d", EPanicUnexpectedStatus);
+__ASSERT_DEBUG(EFalse,User::Panic(Kstub1CcPanicCategory,EPanicUnexpectedStatus));
+		    }
 		if (data[i].iInUse)
 			{
 			continue;
 			}
 			ifc().iEndpointData[0].iInterval = KPollInterval;
 			epFound = ETrue;
 			break;
 			}
 		}
-	LOGTEXT(_L8("\tchecking epFound"));
+	OstTrace0( TRACE_NORMAL, CUSBSTUB1CLASSCONTROLLER_SETUPINTERFACE_DUP8,
+	        _L8("\tchecking epFound"));
 	if ( !epFound )
 		{
-		LOGTEXT2(_L8("<<CCdcControlInterface::SetUpInterface ret=%d"),
+OstTrace1( TRACE_ERROR, CUSBSTUB1CLASSCONTROLLER_SETUPINTERFACE_DUP9,
-			KErrGeneral);
+_L8("<<CCdcControlInterface::SetUpInterface ret=%d"), KErrGeneral);
 		return KErrGeneral;
 		}
 	TName ifcName(KIfcName);
 	ifc().iString = &ifcName;
 	// Codes taken from USBCDC 1.1.
 	ifc().iClass.iClassNum	  = 0x02; // Table 15- Communication Interface Class
 	ifc().iClass.iSubClassNum = 0x02; // Table 16- Abstract Control Model
 	ifc().iClass.iProtocolNum = 0x01; // Table 17- Hayes compatible
-	LOGTEXT(_L8("\tabout to call SetInterface"));
+	OstTrace0( TRACE_NORMAL, CUSBSTUB1CLASSCONTROLLER_SETUPINTERFACE_DUP10,
+	        _L8("\tabout to call SetInterface"));
 	// Zero effectively indicates that alternate interfaces are not used.
 	ret = iLdd.SetInterface(0, ifc);
-	LOGTEXT2(_L8("<<CCdcControlInterface::SetUpInterface ret=%d"), ret);
+	OstTrace1( TRACE_NORMAL, CUSBSTUB1CLASSCONTROLLER_SETUPINTERFACE_DUP11,
+	        _L8("<<CCdcControlInterface::SetUpInterface ret=%d"), ret );
 	return ret;
 	}
 //
 // End of file

branch	RCL_3
changeset 15	f92a4f87e424
parent 0	c9bc50fca66e
child 16	012cc2ee6408