usbmgmt/usbmgr/host/fdf/production/client/src/session.cpp
branchRCL_3
changeset 15 f92a4f87e424
parent 0 c9bc50fca66e
child 16 012cc2ee6408
equal deleted inserted replaced
14:d3e8e7d462dd 15:f92a4f87e424
     1 /*
     1 /*
     2 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
     2 * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).
     3 * All rights reserved.
     3 * All rights reserved.
     4 * This component and the accompanying materials are made available
     4 * This component and the accompanying materials are made available
     5 * under the terms of "Eclipse Public License v1.0"
     5 * under the terms of "Eclipse Public License v1.0"
     6 * which accompanies this distribution, and is available
     6 * which accompanies this distribution, and is available
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
    19  @file
    19  @file
    20  @internalComponent
    20  @internalComponent
    21 */
    21 */
    22 
    22 
    23 #include <e32base.h>
    23 #include <e32base.h>
    24 #include <usb/usblogger.h>
       
    25 #include "usbhoststack.h"
    24 #include "usbhoststack.h"
    26 #include "fdfapi.h"
    25 #include "fdfapi.h"
    27 
    26 #include "OstTraceDefinitions.h"
    28 #ifdef __FLOG_ACTIVE
    27 #ifdef OST_TRACE_COMPILER_IN_USE
    29 _LIT8(KLogComponent, "usbhstcli");
    28 #include "sessionTraces.h"
    30 #endif
    29 #endif
       
    30 
       
    31 
    31 
    32 
    32 /**
    33 /**
    33 Starts the server process.
    34 Starts the server process.
    34 */
    35 */
    35 static TInt StartServer()
    36 static TInt StartServer()
    36 	{
    37 	{
    37 	LOG_STATIC_FUNC_ENTRY
    38     OstTraceFunctionEntry0( _FDF_STARTSERVER_ENTRY );
    38 
    39     
    39 	const TUidType serverUid(KNullUid, KNullUid, KUsbFdfUid);
    40 	const TUidType serverUid(KNullUid, KNullUid, KUsbFdfUid);
    40 
    41 
    41 	//
    42 	//
    42 	// EPOC and EKA2 is easy, we just create a new server process. Simultaneous
    43 	// EPOC and EKA2 is easy, we just create a new server process. Simultaneous
    43 	// launching of two such processes should be detected when the second one
    44 	// launching of two such processes should be detected when the second one
    44 	// attempts to create the server object, failing with KErrAlreadyExists.
    45 	// attempts to create the server object, failing with KErrAlreadyExists.
    45 	//
    46 	//
    46 	RProcess server;
    47 	RProcess server;
    47 	TInt err = server.Create(KUsbFdfImg, KNullDesC, serverUid);
    48 	TInt err = server.Create(KUsbFdfImg, KNullDesC, serverUid);
    48 	LOGTEXT2(_L8("\terr = %d"), err);
    49 	
       
    50 	OstTrace1( TRACE_NORMAL, _FDF_STARTSERVER, "\terr = %d", err );
    49 
    51 
    50 	if ( err != KErrNone )
    52 	if ( err != KErrNone )
    51 		{
    53 		{
       
    54 		OstTraceFunctionExit0( _FDF_STARTSERVER_EXIT );
    52 		return err;
    55 		return err;
    53 		}
    56 		}
    54 
    57 
    55 	TRequestStatus stat;
    58 	TRequestStatus stat;
    56 	server.Rendezvous(stat);
    59 	server.Rendezvous(stat);
    57 
    60 
    58 	if ( stat != KRequestPending )
    61 	if ( stat != KRequestPending )
    59 		{
    62 		{
    60 		LOGTEXT(_L8("\taborting startup"));
    63 		OstTrace0( TRACE_NORMAL, _FDF_STARTSERVER_DUP1, "\taborting startup" );
       
    64 		
    61 		server.Kill(0); 	// abort startup
    65 		server.Kill(0); 	// abort startup
    62 		}
    66 		}
    63 	else
    67 	else
    64 		{
    68 		{
    65 		LOGTEXT(_L8("\tresuming"));
    69 		OstTrace0( TRACE_NORMAL, _FDF_STARTSERVER_DUP2, "\tresuming" );
       
    70 		
    66 		server.Resume();	// logon OK - start the server
    71 		server.Resume();	// logon OK - start the server
    67 		}
    72 		}
    68 
    73 
    69 	User::WaitForRequest(stat); 	// wait for start or death
    74 	User::WaitForRequest(stat); 	// wait for start or death
    70 
    75 
    71 	// we can't use the 'exit reason' if the server panicked as this
    76 	// we can't use the 'exit reason' if the server panicked as this
    72 	// is the panic 'reason' and may be '0' which cannot be distinguished
    77 	// is the panic 'reason' and may be '0' which cannot be distinguished
    73 	// from KErrNone
    78 	// from KErrNone
    74 	LOGTEXT2(_L8("\tstat.Int = %d"), stat.Int());
    79 	OstTrace1( TRACE_NORMAL, _FDF_STARTSERVER_DUP3, "\tstat.Int = %d", stat.Int());
       
    80 	
    75 	err = (server.ExitType() == EExitPanic) ? KErrServerTerminated : stat.Int();
    81 	err = (server.ExitType() == EExitPanic) ? KErrServerTerminated : stat.Int();
    76 
    82 
    77 	server.Close();
    83 	server.Close();
    78 
    84 
    79 	LOGTEXT2(_L8("\terr = %d"), err);
    85 	OstTrace1( TRACE_NORMAL, _FDF_STARTSERVER_DUP4, "\terr = %d", err );
       
    86 	
       
    87 	OstTraceFunctionExit0( _FDF_STARTSERVER_EXIT_DUP1 );
    80 	return err;
    88 	return err;
    81 	}
    89 	}
    82 
    90 
    83 EXPORT_C RUsbHostStack::RUsbHostStack()
    91 EXPORT_C RUsbHostStack::RUsbHostStack()
    84 	// these are all arbitrary initialisations
    92 	// these are all arbitrary initialisations
    85  :	iDeviceEventPckg(TDeviceEventInformation()),
    93  :	iDeviceEventPckg(TDeviceEventInformation()),
    86 	iDevmonEventPckg(0)
    94 	iDevmonEventPckg(0)
    87 	{
    95 	{
    88 	LOGTEXT(_L8("*** Search on '***USB HOST STACK' to find device events."));
    96     OstTraceFunctionEntry0( RUSBHOSTSTACK_RUSBHOSTSTACK_ENTRY );
    89 
    97     
    90 	LOG_LINE
    98 	OstTrace0( TRACE_NORMAL, RUSBHOSTSTACK_RUSBHOSTSTACK, "*** Search on '***USB HOST STACK' to find device events." );
    91 	LOG_FUNC
    99 	    
    92 	}
   100 	}
    93 
   101 
    94 EXPORT_C TVersion RUsbHostStack::Version() const
   102 EXPORT_C TVersion RUsbHostStack::Version() const
    95 	{
   103 	{
    96 	LOG_LINE
   104     OstTraceFunctionEntry0( RUSBHOSTSTACK_VERSION_ENTRY );
    97 	LOG_FUNC
   105         
    98 
       
    99 	return(TVersion(	KUsbFdfSrvMajorVersionNumber,
   106 	return(TVersion(	KUsbFdfSrvMajorVersionNumber,
   100 						KUsbFdfSrvMinorVersionNumber,
   107 						KUsbFdfSrvMinorVersionNumber,
   101 						KUsbFdfSrvBuildNumber
   108 						KUsbFdfSrvBuildNumber
   102 					)
   109 					)
   103 			);
   110 			);
   104 	}
   111 	}
   105 
   112 
   106 EXPORT_C TInt RUsbHostStack::Connect()
   113 EXPORT_C TInt RUsbHostStack::Connect()
   107 	{
   114 	{
   108 	LOG_LINE
   115     OstTraceFunctionEntry0( RUSBHOSTSTACK_CONNECT_ENTRY );
   109 	LOG_FUNC;
   116             
   110 
       
   111 	TInt err = DoConnect();
   117 	TInt err = DoConnect();
   112 
   118 
   113 	LOGTEXT2(_L8("\terr = %d"), err);
   119 	OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_CONNECT, "\terr = %d", err);
       
   120 	    
   114 	return err;
   121 	return err;
   115 	}
   122 	}
   116 
   123 
   117 /**
   124 /**
   118 Connects the session, starting the server if necessary
   125 Connects the session, starting the server if necessary
   119 @return Error.
   126 @return Error.
   120 */
   127 */
   121 TInt RUsbHostStack::DoConnect()
   128 TInt RUsbHostStack::DoConnect()
   122 	{
   129 	{
   123 	LOG_FUNC
   130     OstTraceFunctionEntry0( RUSBHOSTSTACK_DOCONNECT_ENTRY);
       
   131     
   124 
   132 
   125 	TInt retry = 2;
   133 	TInt retry = 2;
   126 
   134 
   127 	FOREVER
   135 	FOREVER
   128 		{
   136 		{
   129 		// Use message slots from the global pool.
   137 		// Use message slots from the global pool.
   130 		TInt err = CreateSession(KUsbFdfServerName, Version(), -1);
   138 		TInt err = CreateSession(KUsbFdfServerName, Version(), -1);
   131 		LOGTEXT2(_L8("\terr = %d"), err);
   139 		OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_DOCONNECT, "\terr = %d", err );
   132 
   140 		
   133 		if ((err != KErrNotFound) && (err != KErrServerTerminated))
   141 		if ((err != KErrNotFound) && (err != KErrServerTerminated))
   134 			{
   142 			{
   135 			LOGTEXT(_L8("\treturning after CreateSession"));
   143 			OstTrace0( TRACE_NORMAL, RUSBHOSTSTACK_DOCONNECT_DUP1, "\treturning after CreateSession" );
       
   144 			
       
   145 			OstTraceFunctionExit0( RUSBHOSTSTACK_DOCONNECT_EXIT);
   136 			return err;
   146 			return err;
   137 			}
   147 			}
   138 
   148 
   139 		if (--retry == 0)
   149 		if (--retry == 0)
   140 			{
   150 			{
   141 			LOGTEXT(_L8("\treturning after running out of retries"));
   151 			OstTrace0( TRACE_NORMAL, RUSBHOSTSTACK_DOCONNECT_DUP2, "\treturning after running out of retries" );
       
   152 			
       
   153 			OstTraceFunctionExit0( RUSBHOSTSTACK_DOCONNECT_EXIT_DUP1 );
   142 			return err;
   154 			return err;
   143 			}
   155 			}
   144 
   156 
   145 		err = StartServer();
   157 		err = StartServer();
   146 		LOGTEXT2(_L8("\terr = %d"), err);
   158 		OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_DOCONNECT_DUT3, "\terr = %d", err );
   147 
   159 		        
   148 		if ((err != KErrNone) && (err != KErrAlreadyExists))
   160 		if ((err != KErrNone) && (err != KErrAlreadyExists))
   149 			{
   161 			{
   150 			LOGTEXT(_L8("\treturning after StartServer"));
   162 			OstTrace0( TRACE_NORMAL, RUSBHOSTSTACK_DOCONNECT_DUP4, "\treturning after StartServer" );
       
   163 			            
       
   164 			OstTraceFunctionExit0( RUSBHOSTSTACK_DOCONNECT_EXIT_DUP2 );
   151 			return err;
   165 			return err;
   152 			}
   166 			}
   153 		}
   167 		}
   154 	}
   168 	}
   155 
   169 
   156 EXPORT_C TInt RUsbHostStack::EnableDriverLoading()
   170 EXPORT_C TInt RUsbHostStack::EnableDriverLoading()
   157 	{
   171 	{
   158 	LOG_LINE
   172     OstTraceFunctionEntry0( RUSBHOSTSTACK_ENABLEDRIVERLOADING_ENTRY );
   159 	LOG_FUNC
   173     
   160 
       
   161 	TInt ret = SendReceive(EUsbFdfSrvEnableDriverLoading);
   174 	TInt ret = SendReceive(EUsbFdfSrvEnableDriverLoading);
   162 	LOGTEXT2(_L8("\tret = %d"), ret);
   175 	OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_ENABLEDRIVERLOADING, "\tret = %d", ret );
       
   176 
       
   177 	OstTraceFunctionExit0( RUSBHOSTSTACK_ENABLEDRIVERLOADING_EXIT );
   163 	return ret;
   178 	return ret;
   164 	}
   179 	}
   165 
   180 
   166 EXPORT_C void RUsbHostStack::DisableDriverLoading()
   181 EXPORT_C void RUsbHostStack::DisableDriverLoading()
   167 	{
   182 	{
   168 	LOG_LINE
   183     OstTraceFunctionEntry0( RUSBHOSTSTACK_DISABLEDRIVERLOADING_ENTRY );
   169 	LOG_FUNC
       
   170 
   184 
   171 	TInt ret = SendReceive(EUsbFdfSrvDisableDriverLoading);
   185 	TInt ret = SendReceive(EUsbFdfSrvDisableDriverLoading);
   172 	LOGTEXT2(_L8("\tret = %d"), ret);
   186 	OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_DISABLEDRIVERLOADING, "\tret = %d", ret );
   173 	(void)ret;
   187 	(void)ret;
       
   188 	OstTraceFunctionExit0( RUSBHOSTSTACK_DISABLEDRIVERLOADING_EXIT );
   174 	}
   189 	}
   175 
   190 
   176 EXPORT_C void RUsbHostStack::NotifyDeviceEvent(TRequestStatus& aStat, TDeviceEventInformation& aDeviceEventInformation)
   191 EXPORT_C void RUsbHostStack::NotifyDeviceEvent(TRequestStatus& aStat, TDeviceEventInformation& aDeviceEventInformation)
   177 	{
   192 	{
   178 	LOG_LINE
   193     OstTraceFunctionEntry0( RUSBHOSTSTACK_NOTIFYDEVICEEVENT_ENTRY );
   179 	LOG_FUNC
   194     
   180 
       
   181 	TIpcArgs args;
   195 	TIpcArgs args;
   182 	iDeviceEventPckg.Set((TUint8*)&aDeviceEventInformation, sizeof(TDeviceEventInformation), sizeof(TDeviceEventInformation));
   196 	iDeviceEventPckg.Set((TUint8*)&aDeviceEventInformation, sizeof(TDeviceEventInformation), sizeof(TDeviceEventInformation));
   183 	args.Set(0, &iDeviceEventPckg);
   197 	args.Set(0, &iDeviceEventPckg);
   184 
   198 
   185 	SendReceive(EUsbFdfSrvNotifyDeviceEvent, args, aStat);
   199 	SendReceive(EUsbFdfSrvNotifyDeviceEvent, args, aStat);
       
   200 	OstTraceFunctionExit0( RUSBHOSTSTACK_NOTIFYDEVICEEVENT_EXIT );
   186 	}
   201 	}
   187 
   202 
   188 EXPORT_C void RUsbHostStack::NotifyDeviceEventCancel()
   203 EXPORT_C void RUsbHostStack::NotifyDeviceEventCancel()
   189 	{
   204 	{
   190 	LOG_LINE
   205 	OstTraceFunctionEntry0( RUSBHOSTSTACK_NOTIFYDEVICEEVENTCANCEL_ENTRY );
   191 	LOG_FUNC
   206 	
   192 
       
   193 	TInt ret = SendReceive(EUsbFdfSrvNotifyDeviceEventCancel);
   207 	TInt ret = SendReceive(EUsbFdfSrvNotifyDeviceEventCancel);
   194 	LOGTEXT2(_L8("\tret = %d"), ret);
   208 	OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_NOTIFYDEVICEEVENTCANCEL, "\tret = %d", ret);
   195 	(void)ret;
   209 	(void)ret;
       
   210 	OstTraceFunctionExit0( RUSBHOSTSTACK_NOTIFYDEVICEEVENTCANCEL_EXIT );
   196 	}
   211 	}
   197 
   212 
   198 EXPORT_C void RUsbHostStack::NotifyDevmonEvent(TRequestStatus& aStat, TInt& aEvent)
   213 EXPORT_C void RUsbHostStack::NotifyDevmonEvent(TRequestStatus& aStat, TInt& aEvent)
   199 	{
   214 	{
   200 	LOG_LINE
   215     OstTraceFunctionEntry0( RUSBHOSTSTACK_NOTIFYDEVMONEVENT_ENTRY );
   201 	LOG_FUNC
   216   
   202 
       
   203 	TIpcArgs args;
   217 	TIpcArgs args;
   204 	iDevmonEventPckg.Set((TUint8*)&aEvent, sizeof(TInt), sizeof(TInt));
   218 	iDevmonEventPckg.Set((TUint8*)&aEvent, sizeof(TInt), sizeof(TInt));
   205 	args.Set(0, &iDevmonEventPckg);
   219 	args.Set(0, &iDevmonEventPckg);
   206 
   220 
   207 	SendReceive(EUsbFdfSrvNotifyDevmonEvent, args, aStat);
   221 	SendReceive(EUsbFdfSrvNotifyDevmonEvent, args, aStat);
       
   222 	OstTraceFunctionExit0( RUSBHOSTSTACK_NOTIFYDEVMONEVENT_EXIT );
   208 	}
   223 	}
   209 
   224 
   210 EXPORT_C void RUsbHostStack::NotifyDevmonEventCancel()
   225 EXPORT_C void RUsbHostStack::NotifyDevmonEventCancel()
   211 	{
   226 	{
   212 	LOG_LINE
   227     OstTraceFunctionEntry0( RUSBHOSTSTACK_NOTIFYDEVMONEVENTCANCEL_ENTRY );
   213 	LOG_FUNC
   228     
   214 
       
   215 	TInt ret = SendReceive(EUsbFdfSrvNotifyDevmonEventCancel);
   229 	TInt ret = SendReceive(EUsbFdfSrvNotifyDevmonEventCancel);
   216 	LOGTEXT2(_L8("\tret = %d"), ret);
   230 	OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_NOTIFYDEVMONEVENTCANCEL, "\tret = %d", ret);
   217 	(void)ret;
   231 	(void)ret;
       
   232 	OstTraceFunctionExit0( RUSBHOSTSTACK_NOTIFYDEVMONEVENTCANCEL_EXIT );
   218 	}
   233 	}
   219 
   234 
   220 EXPORT_C TInt RUsbHostStack::GetSupportedLanguages(TUint aDeviceId, RArray<TUint>& aLangIds)
   235 EXPORT_C TInt RUsbHostStack::GetSupportedLanguages(TUint aDeviceId, RArray<TUint>& aLangIds)
   221 	{
   236 	{
   222 	LOG_LINE
   237     OstTraceFunctionEntry0( RUSBHOSTSTACK_GETSUPPORTEDLANGUAGES_ENTRY );
   223 	LOG_FUNC
   238     
   224 
       
   225 	aLangIds.Reset();
   239 	aLangIds.Reset();
   226 
   240 
   227 	TUint singleLangIdOrNumLangs = 0;
   241 	TUint singleLangIdOrNumLangs = 0;
   228 	TPckg<TUint> singleLangIdOrNumLangsBuf(singleLangIdOrNumLangs);
   242 	TPckg<TUint> singleLangIdOrNumLangsBuf(singleLangIdOrNumLangs);
   229 	TInt ret = SendReceive(EUsbFdfSrvGetSingleSupportedLanguageOrNumberOfSupportedLanguages, TIpcArgs(aDeviceId, &singleLangIdOrNumLangsBuf));
   243 	TInt ret = SendReceive(EUsbFdfSrvGetSingleSupportedLanguageOrNumberOfSupportedLanguages, TIpcArgs(aDeviceId, &singleLangIdOrNumLangsBuf));
   230 	LOGTEXT2(_L8("\tsingleLangIdOrNumLangs = %d"), singleLangIdOrNumLangs);
   244 	OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_GETSUPPORTEDLANGUAGES, "\tsingleLangIdOrNumLangs = %d", singleLangIdOrNumLangs);
       
   245 	    
   231 	switch ( ret )
   246 	switch ( ret )
   232 		{
   247 		{
   233 	case KErrNotFound:
   248 	case KErrNotFound:
   234 		LOGTEXT2(_L8("\tThere is no language available or the wrong device id %d was supplied"),aDeviceId);
   249 		OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_GETSUPPORTEDLANGUAGES_DUP1, "\tThere is no language available or the wrong device id %d was supplied",aDeviceId);
       
   250 		    
   235 		ret = KErrNotFound;
   251 		ret = KErrNotFound;
   236 		break;
   252 		break;
   237 
   253 
   238 	case KErrNone:
   254 	case KErrNone:
   239 		// The buffer is now either empty or contains the single supported language ID
   255 		// The buffer is now either empty or contains the single supported language ID
   261 	default:
   277 	default:
   262 		// Regular failure.
   278 		// Regular failure.
   263 		break;
   279 		break;
   264 		}
   280 		}
   265 
   281 
   266 	LOGTEXT2(_L8("\tret = %d"), ret);
   282 	OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_GETSUPPORTEDLANGUAGES_DUP2, "\tret = %d", ret);
       
   283 	    
       
   284 	OstTraceFunctionExit0( RUSBHOSTSTACK_GETSUPPORTEDLANGUAGES_EXIT );
   267 	return ret;
   285 	return ret;
   268 	}
   286 	}
   269 
   287 
   270 TInt RUsbHostStack::CopyLangIdsToArray(RArray<TUint>& aLangIds, const TDesC8& aBuffer)
   288 TInt RUsbHostStack::CopyLangIdsToArray(RArray<TUint>& aLangIds, const TDesC8& aBuffer)
   271 	{
   289 	{
   272 	LOG_FUNC
   290     OstTraceFunctionEntry0( RUSBHOSTSTACK_COPYLANGIDSTOARRAY_ENTRY );
   273 
   291     
   274 	ASSERT(!(aBuffer.Size() % 4));
   292 	ASSERT(!(aBuffer.Size() % 4));
   275 	const TUint numLangs = aBuffer.Size() / 4;
   293 	const TUint numLangs = aBuffer.Size() / 4;
   276 	LOGTEXT2(_L8("\tnumLangs = %d"), numLangs);
   294 	
   277 
   295 	OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_COPYLANGIDSTOARRAY, "\tnumLangs = %d", numLangs );
       
   296 	
   278 	TInt ret = KErrNone;
   297 	TInt ret = KErrNone;
   279 	const TUint* ptr = reinterpret_cast<const TUint*>(aBuffer.Ptr());
   298 	const TUint* ptr = reinterpret_cast<const TUint*>(aBuffer.Ptr());
   280 	for ( TUint ii = 0 ; ii < numLangs ; ++ii )
   299 	for ( TUint ii = 0 ; ii < numLangs ; ++ii )
   281 		{
   300 		{
   282 		ret = aLangIds.Append(*ptr++); // increments by sizeof(TUint)
   301 		ret = aLangIds.Append(*ptr++); // increments by sizeof(TUint)
   285 			aLangIds.Reset();
   304 			aLangIds.Reset();
   286 			break;
   305 			break;
   287 			}
   306 			}
   288 		}
   307 		}
   289 
   308 
   290 	LOGTEXT2(_L8("\tret = %d"), ret);
   309 	OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_COPYLANGIDSTOARRAY_DUP1, "\tret = %d", ret );
       
   310 	    
       
   311 	OstTraceFunctionExit0( RUSBHOSTSTACK_COPYLANGIDSTOARRAY_EXIT );
   291 	return ret;
   312 	return ret;
   292 	}
   313 	}
   293 
   314 
   294 EXPORT_C TInt RUsbHostStack::GetManufacturerStringDescriptor(TUint aDeviceId, TUint aLangId, TName& aString)
   315 EXPORT_C TInt RUsbHostStack::GetManufacturerStringDescriptor(TUint aDeviceId, TUint aLangId, TName& aString)
   295 	{
   316 	{
   296 	LOG_LINE
   317 	OstTraceFunctionEntry0( RUSBHOSTSTACK_GETMANUFACTURERSTRINGDESCRIPTOR_ENTRY );
   297 	LOG_FUNC
   318 	
   298 
       
   299 	TInt ret = SendReceive(EUsbFdfSrvGetManufacturerStringDescriptor, TIpcArgs(aDeviceId, aLangId, &aString));
   319 	TInt ret = SendReceive(EUsbFdfSrvGetManufacturerStringDescriptor, TIpcArgs(aDeviceId, aLangId, &aString));
   300 #ifdef __FLOG_ACTIVE
       
   301 	if ( !ret )
   320 	if ( !ret )
   302 		{
   321 		{
   303 		LOGTEXT2(_L("\taString = \"%S\""), &aString);
   322         OstTraceExt1( TRACE_NORMAL, RUSBHOSTSTACK_GETMANUFACTURERSTRINGDESCRIPTOR, "RUsbHostStack::GetManufacturerStringDescriptor;aString=%S", aString );
   304 		}
   323         
   305 #endif
   324         }
   306 	LOGTEXT2(_L8("\tret = %d"), ret);
   325 	
       
   326 	OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_GETMANUFACTURERSTRINGDESCRIPTOR_DUP1, "\tret = %d", ret );
       
   327 	        
       
   328 	OstTraceFunctionExit0( RUSBHOSTSTACK_GETMANUFACTURERSTRINGDESCRIPTOR_EXIT );
   307 	return ret;
   329 	return ret;
   308 	}
   330 	}
   309 
   331 
   310 EXPORT_C TInt RUsbHostStack::GetProductStringDescriptor(TUint aDeviceId, TUint aLangId, TName& aString)
   332 EXPORT_C TInt RUsbHostStack::GetProductStringDescriptor(TUint aDeviceId, TUint aLangId, TName& aString)
   311 	{
   333 	{
   312 	LOG_LINE
   334     OstTraceFunctionEntry0( RUSBHOSTSTACK_GETPRODUCTSTRINGDESCRIPTOR_ENTRY );
   313 	LOG_FUNC
   335     
   314 
       
   315 	TInt ret = SendReceive(EUsbFdfSrvGetProductStringDescriptor, TIpcArgs(aDeviceId, aLangId, &aString));
   336 	TInt ret = SendReceive(EUsbFdfSrvGetProductStringDescriptor, TIpcArgs(aDeviceId, aLangId, &aString));
   316 #ifdef __FLOG_ACTIVE
       
   317 	if ( !ret )
   337 	if ( !ret )
   318 		{
   338 		{
   319 		LOGTEXT2(_L("\taString = \"%S\""), &aString);
   339 		OstTraceExt1( TRACE_NORMAL, RUSBHOSTSTACK_GETPRODUCTSTRINGDESCRIPTOR, "\taString = \"%S\"", aString );
   320 		}
   340 	
   321 #endif
   341 		
   322 	LOGTEXT2(_L8("\tret = %d"), ret);
   342 		}
       
   343 	OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_GETPRODUCTSTRINGDESCRIPTOR_DUP1, "\tret = %d", ret );
       
   344 	
       
   345 	        
       
   346 	OstTraceFunctionExit0( RUSBHOSTSTACK_GETPRODUCTSTRINGDESCRIPTOR_EXIT );
   323 	return ret;
   347 	return ret;
   324 	}
   348 	}
   325 
   349 
   326 EXPORT_C TInt RUsbHostStack::GetOtgDescriptor(TUint aDeviceId, TOtgDescriptor& aDescriptor)
   350 EXPORT_C TInt RUsbHostStack::GetOtgDescriptor(TUint aDeviceId, TOtgDescriptor& aDescriptor)
   327 	{
   351 	{
   328 	LOG_LINE
   352     OstTraceFunctionEntry0( RUSBHOSTSTACK_GETOTGDESCRIPTOR_ENTRY );
   329 	LOG_FUNC
   353     
   330 
   354 
   331 	TPckg<TOtgDescriptor> otgDescriptorPckg(aDescriptor);
   355 	TPckg<TOtgDescriptor> otgDescriptorPckg(aDescriptor);
   332 	
   356 	
   333 	TIpcArgs args;
   357 	TIpcArgs args;
   334 	args.Set(0, aDeviceId);
   358 	args.Set(0, aDeviceId);
   335 	args.Set(1, &otgDescriptorPckg);
   359 	args.Set(1, &otgDescriptorPckg);
   336 
   360 
   337 	TInt ret = SendReceive(EUsbFdfSrvGetOtgDescriptor, args);
   361 	TInt ret = SendReceive(EUsbFdfSrvGetOtgDescriptor, args);
   338 #ifdef __FLOG_ACTIVE
       
   339 	if ( !ret )
   362 	if ( !ret )
   340 		{
   363 		{
   341 		LOGTEXT2(_L("\taDescriptor.iDeviceId = %d"), aDescriptor.iDeviceId);
   364         OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_GETOTGDESCRIPTOR, "\taDescriptor.iDeviceId = %d", aDescriptor.iDeviceId );
   342 		LOGTEXT2(_L("\taDescriptor.iAttributes = %d"), aDescriptor.iAttributes);
   365         OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_GETOTGDESCRIPTOR_DUP1, "\taDescriptor.iAttributes = %d", aDescriptor.iAttributes );
   343 		}
   366 		}
   344 #endif
   367 	OstTrace1( TRACE_NORMAL, RUSBHOSTSTACK_GETOTGDESCRIPTOR_DUP2, "\tret = %d", ret );
   345 	LOGTEXT2(_L8("\tret = %d"), ret);
   368 	        
       
   369 	OstTraceFunctionExit0( RUSBHOSTSTACK_GETOTGDESCRIPTOR_EXIT );
   346 	return ret;
   370 	return ret;
   347 	}
   371 	}
   348 
   372 
   349 EXPORT_C TInt RUsbHostStack::__DbgFailNext(TInt aCount)
   373 EXPORT_C TInt RUsbHostStack::__DbgFailNext(TInt aCount)
   350 	{
   374 	{