Mercurial Mercurial > oss > MCL > sf > os > usb / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
usbmgmt/usbmgr/device/classdrivers/obex/classcontroller/src/CUsbObexClassController.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) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
 
     2 * Copyright (c) 1997-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".
 
    21 */
 
    21 */
 
    22 
    22 
    23 #include "CUsbObexClassController.h"
 
    23 #include "CUsbObexClassController.h"
 
    24 #include <usb_std.h>
 
    24 #include <usb_std.h>
 
    25 #include <d32usbc.h>
 
    25 #include <d32usbc.h>
 
    26 #include <usb/usblogger.h>
 
    26 #include "OstTraceDefinitions.h"
 
    27 
    27 #ifdef OST_TRACE_COMPILER_IN_USE
 
    28 #ifdef __FLOG_ACTIVE
 
    28 #include "CUsbObexClassControllerTraces.h"
 
    29 _LIT8(KLogComponent, "OBEXCC");
 
       
    30 #endif
 
    29 #endif
 
    31 
    30 
    32 
    31 #ifdef _DEBUG
 
    33 // Panic category only used in debug builds
 
    32 // Panic category only used in debug builds
 
    34 #ifdef _DEBUG
 
       
    35 _LIT( KObexCcPanicCategory, "UsbObexCc" );
 
    33 _LIT( KObexCcPanicCategory, "UsbObexCc" );
 
    36 #endif
 
    34 #endif
 
       
    35 
    37 
    36 
    38 /**
 
    37 /**
 
    39  * Panic codes for the USB OBEX Class Controller.
 
    38  * Panic codes for the USB OBEX Class Controller.
 
    40  */
 
    39  */
 
    41 enum TObexCCPanic
 
    40 enum TObexCCPanic
 
    57  * @return A new CUsbObexClassController object
 
    56  * @return A new CUsbObexClassController object
 
    58  */
 
    57  */
 
    59 CUsbObexClassController* CUsbObexClassController::NewL(
 
    58 CUsbObexClassController* CUsbObexClassController::NewL(
 
    60 	MUsbClassControllerNotify& aOwner)
 
    59 	MUsbClassControllerNotify& aOwner)
 
    61 	{
 
    60 	{
 
    62 	LOG_STATIC_FUNC_ENTRY
 
    61 	OstTraceFunctionEntry0( REF_CUSBOBEXCLASSCONTROLLER_NEWL_ENTRY );
 
    63 
       
    64 	CUsbObexClassController* self =
 
    62 	CUsbObexClassController* self =
 
    65 		new (ELeave) CUsbObexClassController(aOwner);
 
    63 		new (ELeave) CUsbObexClassController(aOwner);
 
       
    64 	OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_NEWL_EXIT );
 
    66 	return self;
 
    65 	return self;
 
    67 	}
 
    66 	}
 
    68 
    67 
    69 /**
 
    68 /**
 
    70  * Constructor.
 
    69  * Constructor.
 
    73  */
 
    72  */
 
    74 CUsbObexClassController::CUsbObexClassController(
 
    73 CUsbObexClassController::CUsbObexClassController(
 
    75 		MUsbClassControllerNotify& aOwner)
 
    74 		MUsbClassControllerNotify& aOwner)
 
    76 	: CUsbClassControllerPlugIn(aOwner, KObexClassPriority)
 
    75 	: CUsbClassControllerPlugIn(aOwner, KObexClassPriority)
 
    77 	{
 
    76 	{
 
       
    77 	OstTraceFunctionEntry0( REF_CUSBOBEXCLASSCONTROLLER_CUSBOBEXCLASSCONTROLLER_CONS_ENTRY );
 
    78 	iState = EUsbServiceIdle;
 
    78 	iState = EUsbServiceIdle;
 
       
    79 	OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_CUSBOBEXCLASSCONTROLLER_CONS_EXIT );
 
    79 	}
 
    80 	}
 
    80 
    81 
    81 /**
 
    82 /**
 
    82  * Destructor.
 
    83  * Destructor.
 
    83  */
 
    84  */
 
    84 CUsbObexClassController::~CUsbObexClassController()
 
    85 CUsbObexClassController::~CUsbObexClassController()
 
    85 	{
 
    86 	{
 
       
    87 	OstTraceFunctionEntry0( REF_CUSBOBEXCLASSCONTROLLER_CUSBOBEXCLASSCONTROLLER_DES_ENTRY );
 
       
    88 	
    86 	Cancel();
 
    89 	Cancel();
 
    87 	if (iState == EUsbServiceStarted) 
    90 	if (iState == EUsbServiceStarted) 
    88 		{
 
    91 		{
 
    89 		iLdd.ReleaseInterface(0);
 
    92 		iLdd.ReleaseInterface(0);
 
    90 		iLdd.Close();
 
    93 		iLdd.Close();
 
    91 		iLdd2.ReleaseInterface(1);
 
    94 		iLdd2.ReleaseInterface(1);
 
    92 		iLdd2.ReleaseInterface(0);
 
    95 		iLdd2.ReleaseInterface(0);
 
    93 		iLdd2.Close();
 
    96 		iLdd2.Close();
 
    94 		}
 
    97 		}
 
       
    98 	OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_CUSBOBEXCLASSCONTROLLER_DES_EXIT );
 
    95 	}
 
    99 	}
 
    96 
   100 
    97 /**
 
   101 /**
 
    98  * SetupClassAndInterface.
 
   102  * SetupClassAndInterface.
 
    99  *
 
   103  *
 
   102  */
 
   106  */
 
   103 
   107 
   104 
   108 
   105 TInt CUsbObexClassController::SetUpClassAndInterface()
 
   109 TInt CUsbObexClassController::SetUpClassAndInterface()
 
   106 	{
 
   110 	{
 
       
   111 	OstTraceFunctionEntry0( REF_CUSBOBEXCLASSCONTROLLER_SETUPCLASSANDINTERFACE_ENTRY );
 
       
   112 	
   107 	TUsbcInterfaceInfoBuf ifc;
 
   113 	TUsbcInterfaceInfoBuf ifc;
 
   108 	
   114 	
   109 	HBufC16* string = KUsbObexIfc().Alloc();
 
   115 	HBufC16* string = KUsbObexIfc().Alloc();
 
   110 	if (!string)
 
   116 	if (!string)
 
       
   117 		{
 
       
   118 		OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_SETUPCLASSANDINTERFACE_EXIT );
 
   111 		return KErrNoMemory;
 
   119 		return KErrNoMemory;
 
   112 	
   120 		}
 
   113 	ifc().iString = string;
 
   121 	ifc().iString = string;
 
   114 	ifc().iClass.iClassNum = KObexClassNumber;		
   122 	ifc().iClass.iClassNum = KObexClassNumber;		
   115 	ifc().iClass.iSubClassNum = KObexSubClassNumber;
 
   123 	ifc().iClass.iSubClassNum = KObexSubClassNumber;
 
   116 	ifc().iClass.iProtocolNum = KObexProtocolNumber;
 
   124 	ifc().iClass.iProtocolNum = KObexProtocolNumber;
 
   117 	ifc().iTotalEndpointsUsed = 0;
 
   125 	ifc().iTotalEndpointsUsed = 0;
 
   129 
   137 
   130 	delete string;
 
   138 	delete string;
 
   131 
   139 
   132 	if (err != KErrNone) 
   140 	if (err != KErrNone) 
   133 		{ 
   141 		{ 
       
   142 		OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_SETUPCLASSANDINTERFACE_EXIT_DUP1 );
 
   134 		return err;
 
   143 		return err;
 
   135 		}
 
   144 		}
 
   136 
   145 
   137 	TBuf8<200> desc(0);
 
   146 	TBuf8<200> desc(0);
 
   138 
   147 
   162 	desc.Append(dataInt);		
   171 	desc.Append(dataInt);		
   163 
   172 
   164 	err= iLdd.SetCSInterfaceDescriptorBlock(0, desc);
 
   173 	err= iLdd.SetCSInterfaceDescriptorBlock(0, desc);
 
   165 	if (err!= KErrNone)
 
   174 	if (err!= KErrNone)
 
   166 		{
 
   175 		{
 
       
   176         OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_SETUPCLASSANDINTERFACE_EXIT_DUP2 );
 
   167         return err;
 
   177         return err;
 
   168         }
 
   178         }
 
   169 
   179 
   170 	err = iLdd2.Open(0);
 
   180 	err = iLdd2.Open(0);
 
   171 	if (err != KErrNone)
 
   181 	if (err != KErrNone)
 
   172 		{
 
   182 		{
 
       
   183         OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_SETUPCLASSANDINTERFACE_EXIT_DUP3 );
 
   173         return err;
 
   184         return err;
 
   174         }
 
   185         }
 
   175 
   186 
   176 	TUsbcInterfaceInfoBuf dataifc;
 
   187 	TUsbcInterfaceInfoBuf dataifc;
 
   177 
   188 
   188 	
   199 	
   189 	err = iLdd2.SetInterface(0, dataifc);
 
   200 	err = iLdd2.SetInterface(0, dataifc);
 
   190 	if (err != KErrNone) 
   201 	if (err != KErrNone) 
   191 		{
 
   202 		{
 
   192 		iLdd2.Close();
 
   203 		iLdd2.Close();
 
       
   204 		OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_SETUPCLASSANDINTERFACE_EXIT_DUP4 );
 
   193 		return err;
 
   205 		return err;
 
   194 		}
 
   206 		}
 
   195 
   207 
   196 	TUsbDeviceCaps dCaps;
 
   208 	TUsbDeviceCaps dCaps;
 
   197 	TInt ret = iLdd.DeviceCaps(dCaps);
 
   209 	TInt ret = iLdd.DeviceCaps(dCaps);
 
   198 	if (ret != KErrNone) 
   210 	if (ret != KErrNone)
 
       
   211 		{
 
       
   212 		OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_SETUPCLASSANDINTERFACE_EXIT_DUP5 );
 
   199 		return ret;
 
   213 		return ret;
 
   200 	
   214 		}
 
   201 	
   215 	
   202 	TInt n = dCaps().iTotalEndpoints;
 
   216 	TInt n = dCaps().iTotalEndpoints;
 
   203 	if (n < KObexMinNumEndpoints) 
   217 	if (n < KObexMinNumEndpoints)
 
       
   218 		{
 
       
   219 		OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_SETUPCLASSANDINTERFACE_EXIT_DUP6 );
 
   204 		return KErrGeneral;
 
   220 		return KErrGeneral;
 
   205 	
   221 		}
 
   206 	// Endpoints
 
   222 	// Endpoints
 
   207 	TUsbcEndpointData data[KUsbcMaxEndpoints];
 
   223 	TUsbcEndpointData data[KUsbcMaxEndpoints];
 
   208 	TPtr8 dataptr(REINTERPRET_CAST(TUint8*, data), sizeof(data), sizeof(data));
 
   224 	TPtr8 dataptr(REINTERPRET_CAST(TUint8*, data), sizeof(data), sizeof(data));
 
   209 	ret = iLdd.EndpointCaps(dataptr);
 
   225 	ret = iLdd.EndpointCaps(dataptr);
 
   210 	if (ret!= KErrNone) 
   226 	if (ret!= KErrNone)
 
       
   227 		{
 
       
   228 		OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_SETUPCLASSANDINTERFACE_EXIT_DUP7 );
 
   211 		return ret;
 
   229 		return ret;
 
   212 
   230 		}
 
   213 	// Set the active interface
 
   231 	// Set the active interface
 
   214 	
   232 	
   215     TUsbcInterfaceInfoBuf dataifc2;
 
   233     TUsbcInterfaceInfoBuf dataifc2;
 
   216 	TBool foundIn = EFalse;
 
   234 	TBool foundIn = EFalse;
 
   217 	TBool foundOut = EFalse;
 
   235 	TBool foundOut = EFalse;
 
   246 			foundOut = ETrue;
 
   264 			foundOut = ETrue;
 
   247 			}
 
   265 			}
 
   248 		}
 
   266 		}
 
   249 		
   267 		
   250     if (!(foundIn && foundOut)) 
   268     if (!(foundIn && foundOut)) 
       
   269     	{
 
       
   270 		OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_SETUPCLASSANDINTERFACE_EXIT_DUP8 );
 
   251 		return KErrGeneral;
 
   271 		return KErrGeneral;
 
       
   272     	}
 
   252 	
   273 	
   253 	dataifc2().iString = NULL;
 
   274 	dataifc2().iString = NULL;
 
   254 	dataifc2().iClass.iClassNum = KObexDataClass;		
   275 	dataifc2().iClass.iClassNum = KObexDataClass;		
   255 	dataifc2().iClass.iSubClassNum = KObexDataSubClass;
 
   276 	dataifc2().iClass.iSubClassNum = KObexDataSubClass;
 
   256 	dataifc2().iClass.iProtocolNum = 0;
 
   277 	dataifc2().iClass.iProtocolNum = 0;
 
   263 	err = iLdd2.SetInterface(1, dataifc2);
 
   284 	err = iLdd2.SetInterface(1, dataifc2);
 
   264 	if (err != KErrNone) 
   285 	if (err != KErrNone) 
   265 		{
 
   286 		{
 
   266 		iLdd2.ReleaseInterface(0);
 
   287 		iLdd2.ReleaseInterface(0);
 
   267 		iLdd2.Close();
 
   288 		iLdd2.Close();
 
       
   289 		OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_SETUPCLASSANDINTERFACE_EXIT_DUP9 );
 
   268 		return err;
 
   290 		return err;
 
   269 
   291 
   270 		}
 
   292 		}
 
       
   293 
       
   294 	OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_SETUPCLASSANDINTERFACE_EXIT_DUP10 );
 
   271 	return KErrNone;
 
   295 	return KErrNone;
 
   272 	}
 
   296 	}
 
   273 
   297 
   274 /**
 
   298 /**
 
   275  * Called by UsbMan to start this class.
 
   299  * Called by UsbMan to start this class.
 
   276  *
 
   300  *
 
   277  * @param aStatus Will be completed with success or failure.
 
   301  * @param aStatus Will be completed with success or failure.
 
   278  */
 
   302  */
 
   279 void CUsbObexClassController::Start(TRequestStatus& aStatus)
 
   303 void CUsbObexClassController::Start(TRequestStatus& aStatus)
 
   280 	{	
   304 	{	
   281 	LOG_FUNC
 
   305 	OstTraceFunctionEntry0( REF_CUSBOBEXCLASSCONTROLLER_START_ENTRY );
 
   282 
   306 	
   283 	//Start() should never be called if started, starting or stopping (or in state EUsbServiceFatalError)
 
   307 	//Start() should never be called if started, starting or stopping (or in state EUsbServiceFatalError)
 
   284 	__ASSERT_DEBUG( iState == EUsbServiceIdle, _USB_PANIC(KObexCcPanicCategory, EBadApiCallStart) );
 
   308 	if (iState != EUsbServiceIdle)
 
       
   309 		{	
       
   310 		OstTrace1( TRACE_FATAL, CUSBOBEXCLASSCONTROLLER_START, "CUsbObexClassController::Start;iState=%d", (TInt)iState );
 
       
   311 		__ASSERT_DEBUG( EFalse, User::Panic(KObexCcPanicCategory, EBadApiCallStart) );
 
       
   312 		}
 
   285 	
   313 	
   286 	TRequestStatus* reportStatus = &aStatus;
 
   314 	TRequestStatus* reportStatus = &aStatus;
 
   287 	
   315 	
   288 	iState = EUsbServiceStarting;
 
   316 	iState = EUsbServiceStarting;
 
   289 
   317 
   290 	TInt err = User::LoadLogicalDevice(KUsbObexLddName);
 
   318 	TInt err = User::LoadLogicalDevice(KUsbObexLddName);
 
   291 	if (err != KErrNone && err != KErrAlreadyExists) 
   319 	if (err != KErrNone && err != KErrAlreadyExists) 
   292 		{
 
   320 		{
 
   293 		User::RequestComplete(reportStatus, err);
 
   321 		User::RequestComplete(reportStatus, err);
 
   294 		iState = EUsbServiceIdle;
 
   322 		iState = EUsbServiceIdle;
 
       
   323 		OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_START_EXIT );
 
   295 		return;      
   324 		return;      
   296 		} 
   325 		} 
   297 		
   326 		
   298 	err = iLdd.Open(0);
 
   327 	err = iLdd.Open(0);
 
   299 	if(err != KErrNone)
 
   328 	if(err != KErrNone)
 
   300 		{
 
   329 		{
 
   301 		iState = EUsbServiceIdle;
 
   330 		iState = EUsbServiceIdle;
 
   302 		User::RequestComplete(reportStatus, err);
 
   331 		User::RequestComplete(reportStatus, err);
 
   303 
   332 
       
   333 		OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_START_EXIT_DUP1 );
 
   304 		return;	
   334 		return;	
   305 		}
 
   335 		}
 
   306 
   336 
   307 	err = SetUpClassAndInterface();
 
   337 	err = SetUpClassAndInterface();
 
   308 	if (err != KErrNone) 
   338 	if (err != KErrNone) 
   309 		{
 
   339 		{
 
   310 		iLdd.Close();
 
   340 		iLdd.Close();
 
   311 		iState = EUsbServiceIdle;
 
   341 		iState = EUsbServiceIdle;
 
   312 		User::RequestComplete(reportStatus, err);
 
   342 		User::RequestComplete(reportStatus, err);
 
   313 		
   343 		
       
   344 		OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_START_EXIT_DUP2 );
 
   314 		return;
 
   345 		return;
 
   315 		}
 
   346 		}
 
   316 		
   347 		
   317 	iState = EUsbServiceStarted;
 
   348 	iState = EUsbServiceStarted;
 
   318 	User::RequestComplete(reportStatus, KErrNone);
 
   349 	User::RequestComplete(reportStatus, KErrNone);
 
       
   350 	OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_START_EXIT_DUP3 );
 
   319 	}
 
   351 	}
 
   320 
   352 
   321 
   353 
   322 /**
 
   354 /**
 
   323  * Called by UsbMan to stop this class.
 
   355  * Called by UsbMan to stop this class.
 
   324  *
 
   356  *
 
   325  * @param aStatus Will be completed with success or failure.
 
   357  * @param aStatus Will be completed with success or failure.
 
   326  */
 
   358  */
 
   327 void CUsbObexClassController::Stop(TRequestStatus& aStatus)
 
   359 void CUsbObexClassController::Stop(TRequestStatus& aStatus)
 
   328 	{
 
   360 	{
 
   329 	LOG_FUNC
 
   361 	OstTraceFunctionEntry0( REF_CUSBOBEXCLASSCONTROLLER_STOP_ENTRY );
 
   330 
       
   331 	//Stop() should never be called if stopping, idle or starting (or in state EUsbServiceFatalError)
 
   362 	//Stop() should never be called if stopping, idle or starting (or in state EUsbServiceFatalError)
 
   332 	__ASSERT_DEBUG( iState == EUsbServiceStarted, _USB_PANIC(KObexCcPanicCategory, EBadApiCallStop) );
 
   363 	if (iState != EUsbServiceStarted)
 
       
   364 		{
 
       
   365 		OstTrace1( TRACE_FATAL, REF_CUSBOBEXCLASSCONTROLLER_STOP, "CUsbObexClassController::Stop;iState=%d", (TInt)iState );
 
       
   366 		__ASSERT_DEBUG( EFalse, User::Panic(KObexCcPanicCategory, EBadApiCallStop) );
 
       
   367 		}
 
   333 
   368 
   334 	TRequestStatus* ReportStatus = &aStatus;
 
   369 	TRequestStatus* ReportStatus = &aStatus;
 
   335 
   370 
   336 	iState = EUsbServiceStopping;
 
   371 	iState = EUsbServiceStopping;
 
   337 
   372 
   344 	iLdd2.Close();
 
   379 	iLdd2.Close();
 
   345 
   380 
   346 	iState = EUsbServiceIdle;
 
   381 	iState = EUsbServiceIdle;
 
   347 
   382 
   348 	User::RequestComplete(ReportStatus, KErrNone);
 
   383 	User::RequestComplete(ReportStatus, KErrNone);
 
       
   384 	OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_STOP_EXIT );
 
   349 	}
 
   385 	}
 
   350 
   386 
   351 
   387 
   352 /**
 
   388 /**
 
   353  * Returns information about the interfaces supported by this class.
 
   389  * Returns information about the interfaces supported by this class.
 
   354  *
 
   390  *
 
   355  * @param aDescriptorInfo Will be filled in with interface information.
 
   391  * @param aDescriptorInfo Will be filled in with interface information.
 
   356  */
 
   392  */
 
   357 void CUsbObexClassController::GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const
 
   393 void CUsbObexClassController::GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const
 
   358 	{
 
   394 	{
 
       
   395 	OstTraceFunctionEntry0( REF_CUSBOBEXCLASSCONTROLLER_GETDESCRIPTORINFO_ENTRY );
 
   359 	aDescriptorInfo.iNumInterfaces = KObexNumInterfaces;
 
   396 	aDescriptorInfo.iNumInterfaces = KObexNumInterfaces;
 
   360 	aDescriptorInfo.iLength = KObexDescriptorLength;
 
   397 	aDescriptorInfo.iLength = KObexDescriptorLength;
 
       
   398 	OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_GETDESCRIPTORINFO_EXIT );
 
   361 	}
 
   399 	}
 
   362 
   400 
   363 /**
 
   401 /**
 
   364  * Standard active object RunL. 
   402  * Standard active object RunL. 
   365  *
 
   403  *
 
   366  * This is never called as this class does not have any asynchronous requests
 
   404  * This is never called as this class does not have any asynchronous requests
 
   367  */
 
   405  */
 
   368 void CUsbObexClassController::RunL()
 
   406 void CUsbObexClassController::RunL()
 
   369 	{
 
   407 	{
 
   370 	__ASSERT_DEBUG(EFalse, _USB_PANIC(KObexCcPanicCategory, EUnusedFunction));
 
   408 	OstTraceFunctionEntry0( REF_CUSBOBEXCLASSCONTROLLER_RUNL_ENTRY );
 
       
   409 	OstTrace0( TRACE_FATAL, REF_CUSBOBEXCLASSCONTROLLER_RUNL, "CUsbObexClassController::RunL;EUnusedFunction" );
 
       
   410 	__ASSERT_DEBUG( EFalse, User::Panic(KObexCcPanicCategory, EUnusedFunction) );
 
       
   411 	OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_RUNL_EXIT );
 
   371 	}
 
   412 	}
 
   372 
   413 
   373 /**
 
   414 /**
 
   374  * Standard active object cancellation function. 
   415  * Standard active object cancellation function. 
   375  *
 
   416  *
 
   376  * Will only be called when an asynchronous request is currently active.
 
   417  * Will only be called when an asynchronous request is currently active.
 
   377  */
 
   418  */
 
   378 void CUsbObexClassController::DoCancel()
 
   419 void CUsbObexClassController::DoCancel()
 
   379 	{
 
   420 	{
 
   380 	__ASSERT_DEBUG(EFalse, _USB_PANIC(KObexCcPanicCategory, EUnusedFunction));
 
   421 	OstTraceFunctionEntry0( REF_CUSBOBEXCLASSCONTROLLER_DOCANCEL_ENTRY );
 
       
   422 	OstTrace0( TRACE_FATAL, REF_CUSBOBEXCLASSCONTROLLER_DOCANCEL, "CUsbObexClassController::DoCancel;EUnusedFunction" );
 
       
   423 	__ASSERT_DEBUG( EFalse, User::Panic(KObexCcPanicCategory, EUnusedFunction) );
 
       
   424 	OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_DOCANCEL_EXIT );
 
   381 	}
 
   425 	}
 
   382 
   426 
   383 /**
 
   427 /**
 
   384  * Standard active object error-handling function. 
   428  * Standard active object error-handling function. 
   385  *
 
   429  *
 
   387  * should never be called as there is another mechanism for catching errors.
 
   431  * should never be called as there is another mechanism for catching errors.
 
   388  */
 
   432  */
 
   389 
   433 
   390 TInt CUsbObexClassController::RunError(TInt /*aError*/)
 
   434 TInt CUsbObexClassController::RunError(TInt /*aError*/)
 
   391 	{
 
   435 	{
 
   392 	__ASSERT_DEBUG(EFalse, _USB_PANIC(KObexCcPanicCategory, EUnusedFunction));
 
   436 	OstTraceFunctionEntry0( REF_CUSBOBEXCLASSCONTROLLER_RUNERROR_ENTRY );
 
       
   437 	OstTrace0( TRACE_FATAL, REF_CUSBOBEXCLASSCONTROLLER_RUNERROR, "CUsbObexClassController::RunError;EUnusedFunction" );
 
       
   438 	__ASSERT_DEBUG( EFalse, User::Panic(KObexCcPanicCategory, EUnusedFunction) );
 
       
   439 	OstTraceFunctionExit0( REF_CUSBOBEXCLASSCONTROLLER_RUNERROR_EXIT );
 
   393 	return KErrNone;
 
   440 	return KErrNone;
 
   394 	}
 
   441 	}
MCL/sf/os/usb