1 /*

     1 /*

     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".

    23 #include "fdf.h"

    23 #include "fdf.h"

    24 #include <usb/usblogger.h>

    24 #include <usb/usblogger.h>

    25 #include "utils.h"

    25 #include "utils.h"

    26 #include <usbhost/internal/fdcplugin.hrh>

    26 #include <usbhost/internal/fdcplugin.hrh>

    27 #include "eventqueue.h"

    27 #include "eventqueue.h"

    31 #endif

    31 #endif

    32 

    33 

    33 _LIT(KDriverUsbhubLddFileName,"usbhubdriver");

    34 _LIT(KDriverUsbhubLddFileName,"usbhubdriver");

    34 _LIT(KDriverUsbdiLddFileName,"usbdi");

    35 _LIT(KDriverUsbdiLddFileName,"usbdi");

    35 

    36 

    37 

    38 

    38 const TUint KVendorSpecificDeviceClassValue = 0xFF;

    39 const TUint KVendorSpecificDeviceClassValue = 0xFF;

    39 const TUint KVendorSpecificInterfaceClassValue = 0xFF;

    40 const TUint KVendorSpecificInterfaceClassValue = 0xFF;

    40 const TUint KMaxSearchKeyLength = 64; 

    41 const TUint KMaxSearchKeyLength = 64; 

    41 

    42 

    42 // Factory function for TInterfaceInfo objects.

    43 // Factory function for TInterfaceInfo objects.

    43 CFdf::TInterfaceInfo* CFdf::TInterfaceInfo::NewL(RPointerArray<CFdf::TInterfaceInfo>& aInterfaces)

    44 CFdf::TInterfaceInfo* CFdf::TInterfaceInfo::NewL(RPointerArray<CFdf::TInterfaceInfo>& aInterfaces)

    44 	{

    45 	{

    46 

    47 

    47 	TInterfaceInfo* self = new(ELeave) TInterfaceInfo;

    48 	TInterfaceInfo* self = new(ELeave) TInterfaceInfo;

    48 	CleanupStack::PushL(self);

    49 	CleanupStack::PushL(self);

    49 	aInterfaces.AppendL(self);

    50 	aInterfaces.AppendL(self);

    50 	CLEANUPSTACK_POP1(self);

    51 	CLEANUPSTACK_POP1(self);

    51 	return self;

    53 	return self;

    52 	}

    54 	}

    53 

    55 

    54 

    56 

    55 CFdf* CFdf::NewL()

    57 CFdf* CFdf::NewL()

    56 	{

    58 	{

    58 

    60 

    59 	CFdf* self = new(ELeave) CFdf;

    61 	CFdf* self = new(ELeave) CFdf;

    60 	CleanupStack::PushL(self);

    62 	CleanupStack::PushL(self);

    61 	self->ConstructL();

    63 	self->ConstructL();

    62 	CLEANUPSTACK_POP1(self);

    64 	CLEANUPSTACK_POP1(self);

    63 	return self;

    66 	return self;

    64 	}

    67 	}

    65 

    68 

    66 CFdf::CFdf()

    69 CFdf::CFdf()

    67 :	iDevices(_FOFF(CDeviceProxy, iLink)),

    70 :	iDevices(_FOFF(CDeviceProxy, iLink)),

    68 	iFunctionDrivers(_FOFF(CFdcProxy, iLink))

    71 	iFunctionDrivers(_FOFF(CFdcProxy, iLink))

    69 	{

    72 	{

    71 	}

    74 	}

    72 

    75 

    73 void CFdf::ConstructL()

    76 void CFdf::ConstructL()

    74 	{

    77 	{

    77 #ifndef __OVER_DUMMYUSBDI__

    80 #ifndef __OVER_DUMMYUSBDI__

    78 	// If we're using the DummyUSBDI we don't need the real USBDI.

    81 	// If we're using the DummyUSBDI we don't need the real USBDI.

    79 	TInt err = User::LoadLogicalDevice(KDriverUsbhubLddFileName);

    82 	TInt err = User::LoadLogicalDevice(KDriverUsbhubLddFileName);

    80 	if ( err != KErrAlreadyExists )

    83 	if ( err != KErrAlreadyExists )

    81 		{

    84 		{

    83 		}

    86 		}

    84 #endif // __OVER_DUMMYUSBDI__

    87 #endif // __OVER_DUMMYUSBDI__

    85 

    88 

    87 

    91 

    88 #ifdef __OVER_DUMMYUSBDI__

    92 #ifdef __OVER_DUMMYUSBDI__

    90 #endif

    97 #endif

    91 

    98 

    92 	iActiveWaitForBusEvent = CActiveWaitForBusEvent::NewL(iHubDriver, iBusEvent, *this);

    99 	iActiveWaitForBusEvent = CActiveWaitForBusEvent::NewL(iHubDriver, iBusEvent, *this);

    93 	iActiveWaitForBusEvent->Wait();	

   100 	iActiveWaitForBusEvent->Wait();	

    94 		

   101 		

    96 	

   103 	

    97 	iActiveWaitForEComEvent = CActiveWaitForEComEvent::NewL(*this);

   104 	iActiveWaitForEComEvent = CActiveWaitForEComEvent::NewL(*this);

    98 	iActiveWaitForEComEvent->Wait();

   105 	iActiveWaitForEComEvent->Wait();

    99 	

   106 	

   100 	iEventQueue = CEventQueue::NewL(*this);

   107 	iEventQueue = CEventQueue::NewL(*this);

   101 	}

   109 	}

   102 

   110 

   103 void CFdf::CreateFunctionDriverProxiesL()

   111 void CFdf::CreateFunctionDriverProxiesL()

   104 	{

   112 	{

   107 	REComSession::ListImplementationsL(TUid::Uid(KFdcEcomInterfaceUid), iImplInfoArray);

   114 	REComSession::ListImplementationsL(TUid::Uid(KFdcEcomInterfaceUid), iImplInfoArray);

   108 	const TUint count = iImplInfoArray.Count();

   115 	const TUint count = iImplInfoArray.Count();

   111 	if ( count == 0 )

   118 	if ( count == 0 )

   112 		{

   119 		{

   115 	else

   122 	else

   116 		{

   123 		{

   119 		}

   129 		}

   120 #endif

   130 #endif

   121 

   131 

   122    	for ( TUint i = 0 ; i < count ; ++i )

   132    	for ( TUint i = 0 ; i < count ; ++i )

   123    		{

   133    		{

   129    		if (proxy->RomBased())

   139    		if (proxy->RomBased())

   130    			iFunctionDrivers.AddFirst(*proxy);

   140    			iFunctionDrivers.AddFirst(*proxy);

   131    		else

   141    		else

   132    			iFunctionDrivers.AddLast(*proxy);

   142    			iFunctionDrivers.AddLast(*proxy);

   133    		}

   143    		}

   134 	}

   145 	}

   135 

   146 

   136 CFdf::~CFdf()

   147 CFdf::~CFdf()

   137 	{

   148 	{

   139 

   150 

   140 	// Mimic the detachment of each attached device.

   151 	// Mimic the detachment of each attached device.

   141 	TSglQueIter<CDeviceProxy> deviceIter(iDevices);

   152 	TSglQueIter<CDeviceProxy> deviceIter(iDevices);

   142 	deviceIter.SetToFirst();

   153 	deviceIter.SetToFirst();

   143 	CDeviceProxy* device;

   154 	CDeviceProxy* device;

   144 	while ( ( device = deviceIter++ ) != NULL )

   155 	while ( ( device = deviceIter++ ) != NULL )

   145 		{

   156 		{

   146 		const TUint deviceId = device->DeviceId();

   157 		const TUint deviceId = device->DeviceId();

   148 		TellFdcsOfDeviceDetachment(deviceId);

   159 		TellFdcsOfDeviceDetachment(deviceId);

   149 		iDevices.Remove(*device);

   160 		iDevices.Remove(*device);

   150 		delete device;

   161 		delete device;

   151 		}

   162 		}

   152 

   163 

   172 	iHubDriver.Close();

   183 	iHubDriver.Close();

   173 

   184 

   174 #ifndef __OVER_DUMMYUSBDI__

   185 #ifndef __OVER_DUMMYUSBDI__

   175 	//If we're using the DummyUSBDI the real USBDI isn't loaded.

   186 	//If we're using the DummyUSBDI the real USBDI isn't loaded.

   176 	TInt err = User::FreeLogicalDevice(KDriverUsbhubLddFileName);

   187 	TInt err = User::FreeLogicalDevice(KDriverUsbhubLddFileName);

   179 	err = User::FreeLogicalDevice(KDriverUsbdiLddFileName);

   189 	err = User::FreeLogicalDevice(KDriverUsbdiLddFileName);

   181 #endif // __OVER_DUMMYUSBDI__

   191 #endif // __OVER_DUMMYUSBDI__

   182 	

   192 	

   183 	delete iEventQueue;

   193 	delete iEventQueue;

   184 

   194 

   185 	// This is a worthwhile check to do at this point. If we ever don't clean

   195 	// This is a worthwhile check to do at this point. If we ever don't clean

   186 	// up iInterfaces at the *right* time, then this will be easier to debug

   196 	// up iInterfaces at the *right* time, then this will be easier to debug

   187 	// than a memory leak.

   197 	// than a memory leak.

   189 

   203 

   190 	iImplInfoArray.ResetAndDestroy();

   204 	iImplInfoArray.ResetAndDestroy();

   191 	REComSession::FinalClose();

   205 	REComSession::FinalClose();

   192 	}

   207 	}

   193 

   208 

   194 void CFdf::EnableDriverLoading()

   209 void CFdf::EnableDriverLoading()

   195 	{

   210 	{

   198 	iDriverLoadingEnabled = ETrue;

   212 	iDriverLoadingEnabled = ETrue;

   199 	}

   213 	}

   200 

   214 

   201 void CFdf::DisableDriverLoading()

   215 void CFdf::DisableDriverLoading()

   202 	{

   216 	{

   205 	iDriverLoadingEnabled = EFalse;

   218 	iDriverLoadingEnabled = EFalse;

   206 	}

   219 	}

   207 

   220 

   208 void CFdf::SetSession(CFdfSession* aSession)

   221 void CFdf::SetSession(CFdfSession* aSession)

   209 	{

   222 	{

   213 	iSession = aSession;

   225 	iSession = aSession;

   214 	}

   226 	}

   215 

   227 

   216 CFdfSession* CFdf::Session()

   228 CFdfSession* CFdf::Session()

   217 	{

   229 	{

   218 	return iSession;

   230 	return iSession;

   219 	}

   231 	}

   220 

   232 

   221 TBool CFdf::GetDeviceEvent(TDeviceEvent& aEvent)

   233 TBool CFdf::GetDeviceEvent(TDeviceEvent& aEvent)

   222 	{

   234 	{

   226 	return iEventQueue->GetDeviceEvent(aEvent);

   242 	return iEventQueue->GetDeviceEvent(aEvent);

   227 	}

   243 	}

   228 

   244 

   229 TBool CFdf::GetDevmonEvent(TInt& aEvent)

   245 TBool CFdf::GetDevmonEvent(TInt& aEvent)

   230 	{

   246 	{

   234 	return iEventQueue->GetDevmonEvent(aEvent);

   256 	return iEventQueue->GetDevmonEvent(aEvent);

   235 	}

   257 	}

   236 	

   258 	

   237 	

   259 	

   238 // An ECom plugin has been installed or removed

   260 // An ECom plugin has been installed or removed

   244 	

   266 	

   245 	}

   267 	}

   246 

   268 

   247 void CFdf::HandleEComEventReceivedL()

   269 void CFdf::HandleEComEventReceivedL()

   248 	{

   270 	{

   251 	// There is no way to filter ecom notification to only receive ones we are interested in, also there is no way

   273 	// There is no way to filter ecom notification to only receive ones we are interested in, also there is no way

   252 	// to query ecom as to what has changed. Hence there is no option but to call ListImplementations().

   274 	// to query ecom as to what has changed. Hence there is no option but to call ListImplementations().

   253 	iImplInfoArray.ResetAndDestroy();		

   275 	iImplInfoArray.ResetAndDestroy();		

   254 			

   276 			

   255 	REComSession::ListImplementationsL(TUid::Uid(KFdcEcomInterfaceUid), iImplInfoArray);	

   277 	REComSession::ListImplementationsL(TUid::Uid(KFdcEcomInterfaceUid), iImplInfoArray);	

   256 	TUint implementationsCount = iImplInfoArray.Count();

   278 	TUint implementationsCount = iImplInfoArray.Count();

   260 	if ( implementationsCount == 0 )

   281 	if ( implementationsCount == 0 )

   261 		{

   282 		{

   264 		

   285 		

   265 	TSglQueIter<CFdcProxy> proxiesIterDebug(iFunctionDrivers);

   286 	TSglQueIter<CFdcProxy> proxiesIterDebug(iFunctionDrivers);

   266 	CFdcProxy* fdcDebug = NULL;		

   287 	CFdcProxy* fdcDebug = NULL;		

   267 	while ( ( fdcDebug = proxiesIterDebug++ ) != NULL )

   288 	while ( ( fdcDebug = proxiesIterDebug++ ) != NULL )

   268 		{

   289 		{

   269 		TUid fdcUid = fdcDebug->ImplUid();

   290 		TUid fdcUid = fdcDebug->ImplUid();

   271 		TInt fdcVersion = fdcDebug->Version();

   292 		TInt fdcVersion = fdcDebug->Version();

   275 	for (TInt kk = 0; kk < implementationsCount; ++kk)

   297 	for (TInt kk = 0; kk < implementationsCount; ++kk)

   276 		{

   298 		{

   277 		TUid fdcUid2 = iImplInfoArray[kk]->ImplementationUid();

   299 		TUid fdcUid2 = iImplInfoArray[kk]->ImplementationUid();

   279 		TInt fdcVersion2 = iImplInfoArray[kk]->Version();

   301 		TInt fdcVersion2 = iImplInfoArray[kk]->Version();

   283 

   304 

   284 	// See if any relevant FDCs (or upgrades) have been installed or uninstalled:	

   305 	// See if any relevant FDCs (or upgrades) have been installed or uninstalled:	

   285 	

   306 	

   286 	// For each FD in the proxy list compare the uid and version with each FD returned by ECom looking

   307 	// For each FD in the proxy list compare the uid and version with each FD returned by ECom looking

   287 	// for the removal, upgrade or downgrade of an existing FD 	

   308 	// for the removal, upgrade or downgrade of an existing FD 	

   377 				iFunctionDrivers.AddFirst(*proxy);

   398 				iFunctionDrivers.AddFirst(*proxy);

   378 			else

   399 			else

   379 				iFunctionDrivers.AddLast(*proxy);			

   400 				iFunctionDrivers.AddLast(*proxy);			

   380 			}

   401 			}

   381 		}

   402 		}

   382 	}

   404 	}

   383 

   405 

   384 // A bus event has occurred.

   406 // A bus event has occurred.

   385 void CFdf::MbeoBusEvent()

   407 void CFdf::MbeoBusEvent()

   386 	{

   408 	{

   391 

   413 

   392 	switch ( iBusEvent.iEventType )

   414 	switch ( iBusEvent.iEventType )

   393 		{

   415 		{

   394 		case RUsbHubDriver::TBusEvent::EDeviceAttached:

   416 		case RUsbHubDriver::TBusEvent::EDeviceAttached:

   395 			if ( !iBusEvent.iError )

   417 			if ( !iBusEvent.iError )

   398 				HandleDeviceAttachment(iBusEvent.iDeviceHandle);

   420 				HandleDeviceAttachment(iBusEvent.iDeviceHandle);

   399 				}

   421 				}

   400 			else

   422 			else

   401 				{

   423 				{

   402 				// It was an attachment failure. Simply tell the event queue.

   424 				// It was an attachment failure. Simply tell the event queue.

   404 				iEventQueue->AttachmentFailure(iBusEvent.iError);

   430 				iEventQueue->AttachmentFailure(iBusEvent.iError);

   405 				}

   431 				}

   406 			break;

   432 			break;

   407 	

   433 	

   408 		case RUsbHubDriver::TBusEvent::EDeviceRemoved:

   434 		case RUsbHubDriver::TBusEvent::EDeviceRemoved:

   409 			// Device detachments are always 'KErrNone'. If the device was

   435 			// Device detachments are always 'KErrNone'. If the device was

   410 			// pseudo-detached due to an overcurrent condition (for instance) then

   436 			// pseudo-detached due to an overcurrent condition (for instance) then

   411 			// the overcurrent condition is indicated through the devmon API (i.e.

   437 			// the overcurrent condition is indicated through the devmon API (i.e.

   412 			// EDevMonEvent) and the detachment is still 'KErrNone'.

   438 			// EDevMonEvent) and the detachment is still 'KErrNone'.

   414 			HandleDeviceDetachment(iBusEvent.iDeviceHandle);

   445 			HandleDeviceDetachment(iBusEvent.iDeviceHandle);

   415 			break;

   446 			break;

   416 	

   447 	

   417 		case RUsbHubDriver::TBusEvent::EDevMonEvent:

   448 		case RUsbHubDriver::TBusEvent::EDevMonEvent:

   418 			HandleDevmonEvent(iBusEvent.iError);

   449 			HandleDevmonEvent(iBusEvent.iError);

   425 

   456 

   426 	// Only re-post the notification when we've finished examining the

   457 	// Only re-post the notification when we've finished examining the

   427 	// TBusEvent from the previous completion. (Otherwise it might get

   458 	// TBusEvent from the previous completion. (Otherwise it might get

   428 	// overwritten.)

   459 	// overwritten.)

   429 	iActiveWaitForBusEvent->Wait();

   460 	iActiveWaitForBusEvent->Wait();

   430 	}

   462 	}

   431 

   463 

   432 // This is the central handler for device attachment.

   464 // This is the central handler for device attachment.

   433 // We deal with device attachments in two phases.

   465 // We deal with device attachments in two phases.

   434 // The first phase is confusingly called device attachment.

   466 // The first phase is confusingly called device attachment.

   435 // The second phase is driver loading.

   467 // The second phase is driver loading.

   436 void CFdf::HandleDeviceAttachment(TUint aDeviceId)

   468 void CFdf::HandleDeviceAttachment(TUint aDeviceId)

   437 	{

   469 	{

   439 	// This is filled in by HandleDeviceAttachmentL on success.

   471 	// This is filled in by HandleDeviceAttachmentL on success.

   440 	CDeviceProxy* device;

   472 	CDeviceProxy* device;

   441 	TRAPD(err, HandleDeviceAttachmentL(aDeviceId, device));

   473 	TRAPD(err, HandleDeviceAttachmentL(aDeviceId, device));

   442 	if ( err )

   474 	if ( err )

   443 		{

   475 		{

   445 		// There was an attachment failure, so we just increment the count of

   477 		// There was an attachment failure, so we just increment the count of

   446 		// attachment failures.

   478 		// attachment failures.

   448 		iEventQueue->AttachmentFailure(err);

   485 		iEventQueue->AttachmentFailure(err);

   449 		// If we failed the attachment phase, we can't try to load drivers for

   486 		// If we failed the attachment phase, we can't try to load drivers for

   450 		// the device.

   487 		// the device.

   451 

   488 

   452 		}

   489 		}

   454 		{

   491 		{

   455 		// This function always moves the 'driver loading' event from the

   492 		// This function always moves the 'driver loading' event from the

   456 		// device proxy created by HandleDeviceAttachmentL to the event queue.

   493 		// device proxy created by HandleDeviceAttachmentL to the event queue.

   457 		// This event object is always populated with the correct status and

   494 		// This event object is always populated with the correct status and

   458 		// error.

   495 		// error.

   460 		DoDriverLoading(*device);

   502 		DoDriverLoading(*device);

   461 		}

   503 		}

   462 

   504 

   463 	// Finally, clean up the collection of information on the device's

   505 	// Finally, clean up the collection of information on the device's

   464 	// interfaces which was populated (maybe only partly) in

   506 	// interfaces which was populated (maybe only partly) in

   465 	// HandleDeviceAttachmentL.

   507 	// HandleDeviceAttachmentL.

   466 	iCurrentDevice = NULL;

   508 	iCurrentDevice = NULL;

   467 	iInterfaces.ResetAndDestroy();

   509 	iInterfaces.ResetAndDestroy();

   468 	}

   511 	}

   469 

   512 

   470 // This does the 'device attachment' phase of the new device attachment only.

   513 // This does the 'device attachment' phase of the new device attachment only.

   471 void CFdf::HandleDeviceAttachmentL(TUint aDeviceId, CDeviceProxy*& aDevice)

   514 void CFdf::HandleDeviceAttachmentL(TUint aDeviceId, CDeviceProxy*& aDevice)

   472 	{

   515 	{

   475 	// Create the device proxy

   517 	// Create the device proxy

   476 	aDevice = CDeviceProxy::NewL(iHubDriver, aDeviceId);

   518 	aDevice = CDeviceProxy::NewL(iHubDriver, aDeviceId);

   477 	CleanupStack::PushL(aDevice);

   519 	CleanupStack::PushL(aDevice);

   478 	iCurrentDevice = aDevice;

   520 	iCurrentDevice = aDevice;

   479 	// Get necessary descriptors (for this phase)

   521 	// Get necessary descriptors (for this phase)

   501 	const TUint8 numberOfInterfaces = iCD.NumInterfaces();

   555 	const TUint8 numberOfInterfaces = iCD.NumInterfaces();

   503 	if ( numberOfInterfaces == 0 )

   557 	if ( numberOfInterfaces == 0 )

   504 		{

   558 		{

   506 		}

   561 		}

   507 

   562 

   508 	// Walk the configuration bundle. Collect information on each interface

   563 	// Walk the configuration bundle. Collect information on each interface

   509 	// (its number, class, subclass and protocol). This populates iInterfaces.

   564 	// (its number, class, subclass and protocol). This populates iInterfaces.

   512 	ParseL(iCD);

   577 	ParseL(iCD);

   513 

   578 

   514 	// Log iInterfaces.

   579 	// Log iInterfaces.

   515 	const TUint interfaceCount = iInterfaces.Count();

   580 	const TUint interfaceCount = iInterfaces.Count();

   519 	for ( TUint ii = 0 ; ii < interfaceCount ; ++ii )

   584 	for ( TUint ii = 0 ; ii < interfaceCount ; ++ii )

   520 		{

   585 		{

   521 		const TInterfaceInfo* ifInfo = iInterfaces[ii];

   586 		const TInterfaceInfo* ifInfo = iInterfaces[ii];

   524 			ii,

   594 			ii,

   525 			ifInfo->iNumber,

   595 			ifInfo->iNumber,

   526 			ifInfo->iClass,

   596 			ifInfo->iClass,

   527 			ifInfo->iSubclass,

   597 			ifInfo->iSubclass,

   528 			ifInfo->iProtocol

   598 			ifInfo->iProtocol

   529 			);

   599 			);

   530 		}

   600 		}

   531 #endif

   601 #endif

   533 	// Check that the config's NumInterfaces is the same as the actual number

   603 	// Check that the config's NumInterfaces is the same as the actual number

   534 	// of interface descriptors we found. We rely on this later on.

   604 	// of interface descriptors we found. We rely on this later on.

   535 	if ( numberOfInterfaces != interfaceCount )

   605 	if ( numberOfInterfaces != interfaceCount )

   536 		{

   606 		{

   538 		}

   609 		}

   539 

   610 

   540 	// Check that each interface number in iInterfaces is unique.

   611 	// Check that each interface number in iInterfaces is unique.

   541 	if ( interfaceCount > 1 )

   612 	if ( interfaceCount > 1 )

   542 		{

   613 		{

   543 		for ( TUint ii = 0 ; ii < interfaceCount ; ++ii )

   614 		for ( TUint ii = 0 ; ii < interfaceCount ; ++ii )

   544 			{

   615 			{

   545 			const TInterfaceInfo* lhs = iInterfaces[ii];

   616 			const TInterfaceInfo* lhs = iInterfaces[ii];

   547 			for ( TUint jj = ii+1 ; jj < interfaceCount ; ++jj )

   623 			for ( TUint jj = ii+1 ; jj < interfaceCount ; ++jj )

   548 				{

   624 				{

   549 				const TInterfaceInfo* rhs = iInterfaces[jj];

   625 				const TInterfaceInfo* rhs = iInterfaces[jj];

   551 				if ( lhs->iNumber == rhs->iNumber )

   632 				if ( lhs->iNumber == rhs->iNumber )

   552 					{

   633 					{

   554 					}

   636 					}

   555 				}

   637 				}

   556 			}

   638 			}

   557 		}

   639 		}

   558 

   640 

   562 	if (iDevices.IsEmpty())

   644 	if (iDevices.IsEmpty())

   563 		{

   645 		{

   564 		TInt err = User::LoadLogicalDevice(KDriverUsbdiLddFileName);

   646 		TInt err = User::LoadLogicalDevice(KDriverUsbdiLddFileName);

   565 		if ( err != KErrAlreadyExists )

   647 		if ( err != KErrAlreadyExists )

   566 			{

   648 			{

   568 			}

   650 			}

   569 		}

   651 		}

   570 #endif // __OVER_DUMMYUSBDI__

   652 #endif // __OVER_DUMMYUSBDI__

   571 	

   653 	

   572 	// Now we know we've succeeded with a device attachment, remove the device

   654 	// Now we know we've succeeded with a device attachment, remove the device

   573 	// proxy from the cleanup stack and put it on the TSglQue.

   655 	// proxy from the cleanup stack and put it on the TSglQue.

   574 	CLEANUPSTACK_POP1(aDevice);

   656 	CLEANUPSTACK_POP1(aDevice);

   575 	iDevices.AddLast(*aDevice);

   657 	iDevices.AddLast(*aDevice);

   576 	// Also put an event on the event queue.

   658 	// Also put an event on the event queue.

   577 	TDeviceEvent* const attachmentEvent = aDevice->GetAttachmentEventObject();

   659 	TDeviceEvent* const attachmentEvent = aDevice->GetAttachmentEventObject();

   579 	attachmentEvent->iInfo.iVid = iDD.VendorId();

   667 	attachmentEvent->iInfo.iVid = iDD.VendorId();

   580 	attachmentEvent->iInfo.iPid = iDD.ProductId();

   668 	attachmentEvent->iInfo.iPid = iDD.ProductId();

   581 	attachmentEvent->iInfo.iError = KErrNone;

   669 	attachmentEvent->iInfo.iError = KErrNone;

   583 	iEventQueue->AddDeviceEvent(*attachmentEvent);

   676 	iEventQueue->AddDeviceEvent(*attachmentEvent);

   585 	}

   680 	}

   586 

   681 

   587 void CFdf::DoDriverLoading(CDeviceProxy& aDevice)

   682 void CFdf::DoDriverLoading(CDeviceProxy& aDevice)

   588 	{

   683 	{

   591 	// Leaving or returning from DoDriverLoadingL is the trigger to put the

   685 	// Leaving or returning from DoDriverLoadingL is the trigger to put the

   592 	// 'driver loading' event object on the event queue. It must already have

   686 	// 'driver loading' event object on the event queue. It must already have

   593 	// been populated correctly (the actual error code it left with doesn't

   687 	// been populated correctly (the actual error code it left with doesn't

   594 	// feed into the driver loading event).

   688 	// feed into the driver loading event).

   595 	TRAP_IGNORE(DoDriverLoadingL(aDevice));

   689 	TRAP_IGNORE(DoDriverLoadingL(aDevice));

   596 	

   690 	

   597 	TDeviceEvent* const driverLoadingEvent = aDevice.GetDriverLoadingEventObject();

   691 	TDeviceEvent* const driverLoadingEvent = aDevice.GetDriverLoadingEventObject();

   599 	// The driver loading event object says whether driver loading succeeded

   698 	// The driver loading event object says whether driver loading succeeded

   600 	// (all interfaces were claimed without error), partly succeeded (not all

   699 	// (all interfaces were claimed without error), partly succeeded (not all

   601 	// interfaces were claimed without error), or failed (no interfaces were

   700 	// interfaces were claimed without error), or failed (no interfaces were

   602 	// claimed without error). This information is intended for USBMAN so it

   701 	// claimed without error). This information is intended for USBMAN so it

   603 	// can tell the user, but we also use it now to suspend the device if

   702 	// can tell the user, but we also use it now to suspend the device if

   606 		{

   705 		{

   607 		// We can't do anything with error here. Suspending the device is for

   706 		// We can't do anything with error here. Suspending the device is for

   608 		// power-saving reasons and is not critical.

   707 		// power-saving reasons and is not critical.

   609 		(void)aDevice.Suspend();

   708 		(void)aDevice.Suspend();

   610 		}

   709 		}

   612 	iEventQueue->AddDeviceEvent(*driverLoadingEvent);

   716 	iEventQueue->AddDeviceEvent(*driverLoadingEvent);

   613 	}

   718 	}

   614 

   719 

   615 

   720 

   616 void CFdf::DoDriverLoadingL(CDeviceProxy& aDevice)

   721 void CFdf::DoDriverLoadingL(CDeviceProxy& aDevice)

   617 	{

   722 	{

   620 	// Check whether driver loading is enabled.

   724 	// Check whether driver loading is enabled.

   621 	if ( !iDriverLoadingEnabled )

   725 	if ( !iDriverLoadingEnabled )

   622 		{

   726 		{

   623 		// Complete driver load failure scenario.

   727 		// Complete driver load failure scenario.

   624 		aDevice.SetDriverLoadingEventData(EDriverLoadFailure, KErrUsbDriverLoadingDisabled);

   728 		aDevice.SetDriverLoadingEventData(EDriverLoadFailure, KErrUsbDriverLoadingDisabled);

   627 

   733 

   628 

   734 

   629 	// Set this member up so that when the FDC calls TokenForInterface we call

   735 	// Set this member up so that when the FDC calls TokenForInterface we call

   630 	// the right proxy object.

   736 	// the right proxy object.

   631 

   737 

   647 	// in the new attached device. Once we finished the device level searching of FDC and we couldn't find any, we

   753 	// in the new attached device. Once we finished the device level searching of FDC and we couldn't find any, we

   648 	// break down the loading process

   754 	// break down the loading process

   649 	if (aDevice.HasIADFlag() && !functionDriverFound)

   755 	if (aDevice.HasIADFlag() && !functionDriverFound)

   650 		{

   756 		{

   651 		aDevice.SetDriverLoadingEventData(EDriverLoadFailure, KErrUsbUnsupportedDevice);

   757 		aDevice.SetDriverLoadingEventData(EDriverLoadFailure, KErrUsbUnsupportedDevice);

   653 		}

   760 		}

   654 	// If a device FD is found then it is supposed to claim all the interfaces, if it didn't then report

   761 	// If a device FD is found then it is supposed to claim all the interfaces, if it didn't then report

   655 	// a partial success but don't offer unclaimed interfaces to any other FD.

   762 	// a partial success but don't offer unclaimed interfaces to any other FD.

   656 	const TUint interfaceCount = iInterfaces.Count();

   763 	const TUint interfaceCount = iInterfaces.Count();

   657 

   764 

   665 	// (a) are there any unclaimed interfaces remaining?

   772 	// (a) are there any unclaimed interfaces remaining?

   666 	// (b) what's in collectedErr?

   773 	// (b) what's in collectedErr?

   667 	// Whether all interfaces were taken, some, or none, collectedErr may have

   774 	// Whether all interfaces were taken, some, or none, collectedErr may have

   668 	// an error in it or KErrNone. We use specific error codes in some cases.			

   775 	// an error in it or KErrNone. We use specific error codes in some cases.			

   669 	TUint unclaimedInterfaces = UnclaimedInterfaceCount();

   776 	TUint unclaimedInterfaces = UnclaimedInterfaceCount();

   674 

   786 

   675 	if(iDeviceDetachedTooEarly)

   787 	if(iDeviceDetachedTooEarly)

   676 		{

   788 		{

   678 		iDeviceDetachedTooEarly = EFalse;

   790 		iDeviceDetachedTooEarly = EFalse;

   679 		// the choice of having the status to be EDriverLoadPartialSuccess

   791 		// the choice of having the status to be EDriverLoadPartialSuccess

   680 		// was not to clash with trying to suspend the device because

   792 		// was not to clash with trying to suspend the device because

   681 		// of a total failure to load the FD.(because device is detached)

   793 		// of a total failure to load the FD.(because device is detached)

   682 		// even though that a FDC has been created

   794 		// even though that a FDC has been created

   688 	else

   800 	else

   689 		{

   801 		{

   690 		SetFailureStatus(unclaimedInterfaces, interfaceCount, anySuccess, collectedErr, aDevice);

   802 		SetFailureStatus(unclaimedInterfaces, interfaceCount, anySuccess, collectedErr, aDevice);

   691 		}// iDeviceDetachedTooEarly

   803 		}// iDeviceDetachedTooEarly

   692 

   804 

   693 	}

   806 	}

   694 

   807 

   695 // Recursive function, originally called with the configuration descriptor.

   808 // Recursive function, originally called with the configuration descriptor.

   696 // Builds up information on the interface descriptors in the configuration

   809 // Builds up information on the interface descriptors in the configuration

   697 // bundle.

   810 // bundle.

   698 void CFdf::ParseL(TUsbGenericDescriptor& aDesc)

   811 void CFdf::ParseL(TUsbGenericDescriptor& aDesc)

   699 	{

   812 	{

   707 		{

   820 		{

   708 		// Add interface information to collection, but only if it's alternate

   821 		// Add interface information to collection, but only if it's alternate

   709 		// setting 0.

   822 		// setting 0.

   710 		const TUsbInterfaceDescriptor& ifDesc = static_cast<TUsbInterfaceDescriptor&>(aDesc);

   823 		const TUsbInterfaceDescriptor& ifDesc = static_cast<TUsbInterfaceDescriptor&>(aDesc);

   711 		if ( ifDesc.AlternateSetting() == 0 ) // hard-coded '0' means the default (initial configuration) setting

   824 		if ( ifDesc.AlternateSetting() == 0 ) // hard-coded '0' means the default (initial configuration) setting

   712 			{

   825 			{

   720 			TInterfaceInfo* ifInfo = TInterfaceInfo::NewL(iInterfaces);

   833 			TInterfaceInfo* ifInfo = TInterfaceInfo::NewL(iInterfaces);

   721 			ifInfo->iNumber = ifDesc.InterfaceNumber();

   834 			ifInfo->iNumber = ifDesc.InterfaceNumber();

   722 			ifInfo->iClass = ifDesc.InterfaceClass();

   835 			ifInfo->iClass = ifDesc.InterfaceClass();

   723 			ifInfo->iSubclass = ifDesc.InterfaceSubClass();

   836 			ifInfo->iSubclass = ifDesc.InterfaceSubClass();

   724 			ifInfo->iProtocol = ifDesc.InterfaceProtocol();

   837 			ifInfo->iProtocol = ifDesc.InterfaceProtocol();

   733 		}

   846 		}

   734 	else if (aDesc.ibDescriptorType == EOTG)

   847 	else if (aDesc.ibDescriptorType == EOTG)

   735 		{

   848 		{

   736 		// OTG descriptor found

   849 		// OTG descriptor found

   737 		const TUsbOTGDescriptor& otgDesc = static_cast<TUsbOTGDescriptor&>(aDesc);

   850 		const TUsbOTGDescriptor& otgDesc = static_cast<TUsbOTGDescriptor&>(aDesc);

   742 		

   854 		

   743 		iCurrentDevice->SetOtgDescriptorL(otgDesc);

   855 		iCurrentDevice->SetOtgDescriptorL(otgDesc);

   744 		}

   856 		}

   745 

   857 

   746 	TUsbGenericDescriptor* const firstChild = aDesc.iFirstChild;

   858 	TUsbGenericDescriptor* const firstChild = aDesc.iFirstChild;

   752 	TUsbGenericDescriptor* const nextPeer = aDesc.iNextPeer;

   864 	TUsbGenericDescriptor* const nextPeer = aDesc.iNextPeer;

   753 	if ( nextPeer )

   865 	if ( nextPeer )

   754 		{

   866 		{

   755 		ParseL(*nextPeer);

   867 		ParseL(*nextPeer);

   756 		}

   868 		}

   757 	}

   870 	}

   758 

   871 

   759 // Method that uses only one array to hold the unclaimed interface numbers.

   872 // Method that uses only one array to hold the unclaimed interface numbers.

   760 void CFdf::FindDriversForInterfacesUsingSpecificKeyL(CDeviceProxy& aDevice,

   873 void CFdf::FindDriversForInterfacesUsingSpecificKeyL(CDeviceProxy& aDevice,

   761 													TInt& aCollectedErr,

   874 													TInt& aCollectedErr,

   762 													TBool& aAnySuccess,			

   875 													TBool& aAnySuccess,			

   763 													RArray<TUint>& aInterfacesNumberArray, 

   876 													RArray<TUint>& aInterfacesNumberArray, 

   764 													TInterfaceSearchKeys aKey)	

   877 													TInterfaceSearchKeys aKey)	

   765 	{

   878 	{

   768 	const TUint interfaceCount = iInterfaces.Count();

   881 	const TUint interfaceCount = iInterfaces.Count();

   769 	for ( TUint ii = 0 ; ii < interfaceCount ; ++ii )

   882 	for ( TUint ii = 0 ; ii < interfaceCount ; ++ii )

   770 		{

   883 		{

   771 		TInterfaceInfo* ifInfo = iInterfaces[ii];		

   884 		TInterfaceInfo* ifInfo = iInterfaces[ii];		

   773 		

   890 		

   774 		if ((ifInfo->iClaimed) ||

   891 		if ((ifInfo->iClaimed) ||

   775 			(aKey == EVendorInterfacesubclassInterfaceprotocol && ifInfo->iClass != KVendorSpecificInterfaceClassValue)||	

   892 			(aKey == EVendorInterfacesubclassInterfaceprotocol && ifInfo->iClass != KVendorSpecificInterfaceClassValue)||	

   776 			(aKey == EVendorInterfacesubclass && ifInfo->iClass != KVendorSpecificInterfaceClassValue) ||

   893 			(aKey == EVendorInterfacesubclass && ifInfo->iClass != KVendorSpecificInterfaceClassValue) ||

   777 			(aKey == EInterfaceclassInterfacesubclassInterfaceprotocol && ifInfo->iClass == KVendorSpecificInterfaceClassValue) ||

   894 			(aKey == EInterfaceclassInterfacesubclassInterfaceprotocol && ifInfo->iClass == KVendorSpecificInterfaceClassValue) ||

   783 			}

   900 			}

   784 		

   901 		

   785 

   902 

   786 		TBuf8<KMaxSearchKeyLength> searchKey;

   903 		TBuf8<KMaxSearchKeyLength> searchKey;

   787 		FormatInterfaceSearchKey(searchKey, aKey, *ifInfo);

   904 		FormatInterfaceSearchKey(searchKey, aKey, *ifInfo);

   790 		// RArray<TUint>* array = &aInterfacesNumberArray;

   906 		// RArray<TUint>* array = &aInterfacesNumberArray;

   791 

   907 

   792 		FindDriverForInterfaceUsingSpecificKey(aDevice, aCollectedErr, aAnySuccess, aInterfacesNumberArray, searchKey);

   908 		FindDriverForInterfaceUsingSpecificKey(aDevice, aCollectedErr, aAnySuccess, aInterfacesNumberArray, searchKey);

   793 

   909 

   794 		// Putting ii+1 as the starting offset is to remove the interface on which

   910 		// Putting ii+1 as the starting offset is to remove the interface on which

   795 		// the searching have been done.		

   911 		// the searching have been done.		

   796 		RebuildUnClaimedInterfacesArrayL(aDevice, aInterfacesNumberArray, ii+1);

   912 		RebuildUnClaimedInterfacesArrayL(aDevice, aInterfacesNumberArray, ii+1);

   797 		}

   913 		}

   798 	}

   915 	}

   799 

   916 

   800 

   917 

   801 

   918 

   802 // Called for one interface, to find a Function Driver on the basis of a

   919 // Called for one interface, to find a Function Driver on the basis of a

   806 								   TInt& aCollectedErr,

   923 								   TInt& aCollectedErr,

   807 								   TBool& aAnySuccess,

   924 								   TBool& aAnySuccess,

   808 								   RArray<TUint>& aInterfacesGivenToFdc,

   925 								   RArray<TUint>& aInterfacesGivenToFdc,

   809 								   const TDesC8& aSearchKey)

   926 								   const TDesC8& aSearchKey)

   810 	{

   927 	{

   814 

   930 

   815 	// Find an FDC matching this search key.

   931 	// Find an FDC matching this search key.

   816 	TSglQueIter<CFdcProxy> iter(iFunctionDrivers);

   932 	TSglQueIter<CFdcProxy> iter(iFunctionDrivers);

   817 	iter.SetToFirst();

   933 	iter.SetToFirst();

   818 	CFdcProxy* fdc;

   934 	CFdcProxy* fdc;

   819 

   935 

   820 	while ( ( fdc = iter++ ) != NULL )

   936 	while ( ( fdc = iter++ ) != NULL )

   821 		{

   937 		{

   823 #ifdef _DEBUG

   940 #ifdef _DEBUG

   824 	// having these two together in the debug window is helpful for interactive debugging

   941 	// having these two together in the debug window is helpful for interactive debugging

   825 	TBuf8<KMaxSearchKeyLength > fd_key;

   942 	TBuf8<KMaxSearchKeyLength > fd_key;

   826 	fd_key.Append(fdc->DefaultDataField().Ptr(), fdc->DefaultDataField().Length() > KMaxSearchKeyLength ? KMaxSearchKeyLength : fdc->DefaultDataField().Length());

   943 	fd_key.Append(fdc->DefaultDataField().Ptr(), fdc->DefaultDataField().Length() > KMaxSearchKeyLength ? KMaxSearchKeyLength : fdc->DefaultDataField().Length());

   827 	TBuf8<KMaxSearchKeyLength > searchKey;

   944 	TBuf8<KMaxSearchKeyLength > searchKey;

   844 			// suitable FDC we found so fa.

   961 			// suitable FDC we found so fa.

   845 			if (!aDevice.MultipleDriversFlag() && FindMultipleFDs(aSearchKey, iter))

   962 			if (!aDevice.MultipleDriversFlag() && FindMultipleFDs(aSearchKey, iter))

   846 				{

   963 				{

   847 				aDevice.SetMultipleDriversFlag();

   964 				aDevice.SetMultipleDriversFlag();

   848 				}

   965 				}

   852 			const TUint count = aInterfacesGivenToFdc.Count();

   968 			const TUint count = aInterfacesGivenToFdc.Count();

   854 			for ( TUint ii = 0 ; ii < count ; ++ii )

   970 			for ( TUint ii = 0 ; ii < count ; ++ii )

   855 				{

   971 				{

   859 			TInt err = fdc->NewFunction(aDevice.DeviceId(), aInterfacesGivenToFdc, iDD, iCD);

   976 			TInt err = fdc->NewFunction(aDevice.DeviceId(), aInterfacesGivenToFdc, iDD, iCD);

   861 			// To correctly determine whether the driver load for the whole

   979 			// To correctly determine whether the driver load for the whole

   862 			// configuration was a complete failure, a partial success or a

   980 			// configuration was a complete failure, a partial success or a

   863 			// complete success, we need to collect any non-KErrNone error

   981 			// complete success, we need to collect any non-KErrNone error

   864 			// from this, and whether any handovers worked at all.

   982 			// from this, and whether any handovers worked at all.

   865 			if ( err == KErrNone )

   983 			if ( err == KErrNone )

   866 				{

   984 				{

   870 				// We want to log each interface that's in

   988 				// We want to log each interface that's in

   871 				// aInterfacesGivenToFdc AND is marked claimed in iInterfaces.

   989 				// aInterfacesGivenToFdc AND is marked claimed in iInterfaces.

   872 				for ( TUint ii = 0 ; ii < aInterfacesGivenToFdc.Count() ; ++ii )

   990 				for ( TUint ii = 0 ; ii < aInterfacesGivenToFdc.Count() ; ++ii )

   873 					{

   991 					{

   874 					const TUint ifNum = aInterfacesGivenToFdc[ii];

   992 					const TUint ifNum = aInterfacesGivenToFdc[ii];

   875 					for ( TUint jj = 0 ; jj < iInterfaces.Count() ; ++jj )

   993 					for ( TUint jj = 0 ; jj < iInterfaces.Count() ; ++jj )

   876 						{

   994 						{

   877 						const TInterfaceInfo* ifInfo = iInterfaces[jj];

   995 						const TInterfaceInfo* ifInfo = iInterfaces[jj];

   879 						if (	ifNum == ifInfo->iNumber

  1002 						if (	ifNum == ifInfo->iNumber

   880 							&&	ifInfo->iClaimed

  1003 							&&	ifInfo->iClaimed

   881 							)

  1004 							)

   882 							{

  1005 							{

   884 							}

  1007 							}

   885 						}

  1008 						}

   886 					}

  1009 					}

   888 				aAnySuccess = ETrue;

  1010 				aAnySuccess = ETrue;

   889 				}

  1011 				}

   890 			else

  1012 			else

   891 				{

  1013 				{

   892 				aCollectedErr = err;

  1014 				aCollectedErr = err;

   893 				}

  1015 				}

   894 			// We found a matching FDC for this interface- no need to look for more.

  1016 			// We found a matching FDC for this interface- no need to look for more.

   895 			break;

  1017 			break;

   896 			}

  1018 			}

   897 		}

  1019 		}

   898 	}

  1021 	}

   899 

  1022 

   900 void CFdf::HandleDeviceDetachment(TUint aDeviceId)

  1023 void CFdf::HandleDeviceDetachment(TUint aDeviceId)

   901 	{

  1024 	{

   905 

  1027 

   906 #ifdef _DEBUG

  1028 #ifdef _DEBUG

   907 	TBool found = EFalse;

  1029 	TBool found = EFalse;

   908 #endif

  1030 #endif

   909 	// Find the relevant device proxy. If there isn't one, just drop the

  1031 	// Find the relevant device proxy. If there isn't one, just drop the

   917 		if ( device->DeviceId() == aDeviceId )

  1039 		if ( device->DeviceId() == aDeviceId )

   918 			{

  1040 			{

   919 #ifdef _DEBUG

  1041 #ifdef _DEBUG

   920 			found = ETrue;

  1042 			found = ETrue;

   921 #endif

  1043 #endif

   924 			iDevices.Remove(*device);

  1046 			iDevices.Remove(*device);

   925 			// Before destroying the device proxy, take the detachment event

  1047 			// Before destroying the device proxy, take the detachment event

   926 			// stored in it for the event queue.

  1048 			// stored in it for the event queue.

   927 			TDeviceEvent* const detachmentEvent = device->GetDetachmentEventObject();

  1049 			TDeviceEvent* const detachmentEvent = device->GetDetachmentEventObject();

   930 			iEventQueue->AddDeviceEvent(*detachmentEvent);

  1060 			iEventQueue->AddDeviceEvent(*detachmentEvent);

   932 			delete device;

  1062 			delete device;

   933 

  1063 

   934 			TellFdcsOfDeviceDetachment(aDeviceId);

  1064 			TellFdcsOfDeviceDetachment(aDeviceId);

   935 			

  1065 			

   936 #ifndef __OVER_DUMMYUSBDI__

  1066 #ifndef __OVER_DUMMYUSBDI__

   937 			// If we're using the DummyUSBDI the real USBDI isn't loaded.

  1067 			// If we're using the DummyUSBDI the real USBDI isn't loaded.

   938 			// Unload USBDI when attached devices goes from 1 to 0

  1068 			// Unload USBDI when attached devices goes from 1 to 0

   939 			if (iDevices.IsEmpty())

  1069 			if (iDevices.IsEmpty())

   940 				{

  1070 				{

   941 				TInt err = User::FreeLogicalDevice(KDriverUsbdiLddFileName);

  1071 				TInt err = User::FreeLogicalDevice(KDriverUsbdiLddFileName);

   943 				}

  1073 				}

   944 #endif // __OVER_DUMMYUSBDI__

  1074 #endif // __OVER_DUMMYUSBDI__

   945 			

  1075 			

   946 			break;

  1076 			break;

   947 			}

  1077 			}

   948 		}

  1078 		}

   949 

  1079 

   950 #ifdef _DEBUG

  1080 #ifdef _DEBUG

   951 	if ( !found )

  1081 	if ( !found )

   952 		{

  1082 		{

   954 		}

  1084 		}

   955 #endif

  1085 #endif

   956 	}

  1088 	}

   957 

  1089 

   958 void CFdf::HandleDevmonEvent(TInt aEvent)

  1090 void CFdf::HandleDevmonEvent(TInt aEvent)

   959 	{

  1091 	{

   964 	iEventQueue->AddDevmonEvent(aEvent);

  1100 	iEventQueue->AddDevmonEvent(aEvent);

   965 	}

  1102 	}

   966 

  1103 

   967 void CFdf::TellFdcsOfDeviceDetachment(TUint aDeviceId)

  1104 void CFdf::TellFdcsOfDeviceDetachment(TUint aDeviceId)

   968 	{

  1105 	{

   972 	TSglQueIter<CFdcProxy> iter(iFunctionDrivers);

  1109 	TSglQueIter<CFdcProxy> iter(iFunctionDrivers);

   973 	iter.SetToFirst();

  1110 	iter.SetToFirst();

   974 	CFdcProxy* fdc;

  1111 	CFdcProxy* fdc;

   975 	while ( ( fdc = iter++ ) != NULL )

  1112 	while ( ( fdc = iter++ ) != NULL )

   976 		{

  1113 		{

   980 			iFunctionDrivers.Remove(*fdc);

  1117 			iFunctionDrivers.Remove(*fdc);

   981 			delete fdc;

  1118 			delete fdc;

   982 			}

  1119 			}

   983 		}			

  1120 		}			

   984 		

  1121 		

   985 	}

  1123 	}

   986 

  1124 

   987 TUint32 CFdf::TokenForInterface(TUint8 aInterface)

  1125 TUint32 CFdf::TokenForInterface(TUint8 aInterface)

   988 	{

  1126 	{

   991 	TUint32 token = 0;

  1130 	TUint32 token = 0;

   992 

  1131 

   993 	// Check that the interface was in the array given to the FD and mark it

  1132 	// Check that the interface was in the array given to the FD and mark it

   994 	// as claimed.

  1133 	// as claimed.

   995 	TBool found = EFalse;

  1134 	TBool found = EFalse;

   996 	const TUint interfaceCount = iInterfaces.Count();

  1135 	const TUint interfaceCount = iInterfaces.Count();

   997 	for ( TUint ii = 0 ; ii < interfaceCount ; ++ii )

  1136 	for ( TUint ii = 0 ; ii < interfaceCount ; ++ii )

   998 		{

  1137 		{

   999 		TInterfaceInfo* ifInfo = iInterfaces[ii];

  1138 		TInterfaceInfo* ifInfo = iInterfaces[ii];

  1001 		if ( ifInfo->iNumber == aInterface )

  1144 		if ( ifInfo->iNumber == aInterface )

  1002 			{

  1145 			{

  1003 			found = ETrue;

  1146 			found = ETrue;

  1004 			// The FDC tried to claim an interface that was already claimed.

  1147 			// The FDC tried to claim an interface that was already claimed.

  1006 			ifInfo->iClaimed = ETrue;

  1153 			ifInfo->iClaimed = ETrue;

  1007 			break;

  1154 			break;

  1008 			}

  1155 			}

  1009 		}

  1156 		}

  1010 	// Could not find interface in the interface array- the FDC tried to claim

  1157 	// Could not find interface in the interface array- the FDC tried to claim

  1011 	// an interface it had not been offered.

  1158 	// an interface it had not been offered.

  1015 

  1170 

  1016 	// GetTokenForInterface will return error in the following cases:

  1171 	// GetTokenForInterface will return error in the following cases:

  1017 	// 1/ KErrBadHandle: invalid device handle (the CDeviceProxy asserts that

  1172 	// 1/ KErrBadHandle: invalid device handle (the CDeviceProxy asserts that

  1018 	// the handle is valid) because the device has been detached while processing

  1173 	// the handle is valid) because the device has been detached while processing

  1019 	// may be due to too much current or cable has been removed

  1174 	// may be due to too much current or cable has been removed

  1037 

  1192 

  1038 		case KErrNone: // Fall through and do nothing

  1193 		case KErrNone: // Fall through and do nothing

  1039 			break;

  1194 			break;

  1040 

  1195 

  1041 		default:

  1196 		default:

  1049 	return token;

  1206 	return token;

  1050 	}

  1207 	}

  1051 

  1208 

  1052 CDeviceProxy* CFdf::DeviceProxyL(TUint aDeviceId) const

  1209 CDeviceProxy* CFdf::DeviceProxyL(TUint aDeviceId) const

  1053 	{

  1210 	{

  1057 	TSglQueIter<CDeviceProxy> iter(const_cast<CFdf*>(this)->iDevices);

  1214 	TSglQueIter<CDeviceProxy> iter(const_cast<CFdf*>(this)->iDevices);

  1058 	iter.SetToFirst();

  1215 	iter.SetToFirst();

  1059 	CDeviceProxy* device = NULL;

  1216 	CDeviceProxy* device = NULL;

  1060 	while ( ( device = iter++ ) != NULL )

  1217 	while ( ( device = iter++ ) != NULL )

  1061 		{

  1218 		{

  1062 		if ( device->DeviceId() == aDeviceId )

  1219 		if ( device->DeviceId() == aDeviceId )

  1063 			{

  1220 			{

  1065 			return device;

  1223 			return device;

  1066 			}

  1224 			}

  1067 		}

  1225 		}

  1069 	return NULL; // avoid warning

  1229 	return NULL; // avoid warning

  1070 	}

  1230 	}

  1071 

  1231 

  1072 const RArray<TUint>& CFdf::GetSupportedLanguagesL(TUint aDeviceId) const

  1232 const RArray<TUint>& CFdf::GetSupportedLanguagesL(TUint aDeviceId) const

  1073 	{

  1233 	{

  1077 	CDeviceProxy* deviceProxy = DeviceProxyL(aDeviceId);

  1237 	CDeviceProxy* deviceProxy = DeviceProxyL(aDeviceId);

  1078 	return deviceProxy->GetSupportedLanguages();

  1238 	return deviceProxy->GetSupportedLanguages();

  1079 	}

  1239 	}

  1080 

  1240 

  1081 void CFdf::GetManufacturerStringDescriptorL(TUint aDeviceId, TUint32 aLangId, TName& aString) const

  1241 void CFdf::GetManufacturerStringDescriptorL(TUint aDeviceId, TUint32 aLangId, TName& aString) const

  1082 	{

  1242 	{

  1086 	CDeviceProxy* deviceProxy = DeviceProxyL(aDeviceId);

  1247 	CDeviceProxy* deviceProxy = DeviceProxyL(aDeviceId);

  1087 	deviceProxy->GetManufacturerStringDescriptorL(aLangId, aString);

  1248 	deviceProxy->GetManufacturerStringDescriptorL(aLangId, aString);

  1089 	}

  1251 	}

  1090 

  1252 

  1091 void CFdf::GetProductStringDescriptorL(TUint aDeviceId, TUint32 aLangId, TName& aString) const

  1253 void CFdf::GetProductStringDescriptorL(TUint aDeviceId, TUint32 aLangId, TName& aString) const

  1092 	{

  1254 	{

  1095 

  1258 

  1096 	CDeviceProxy* deviceProxy = DeviceProxyL(aDeviceId);

  1259 	CDeviceProxy* deviceProxy = DeviceProxyL(aDeviceId);

  1097 	deviceProxy->GetProductStringDescriptorL(aLangId, aString);

  1260 	deviceProxy->GetProductStringDescriptorL(aLangId, aString);

  1099 	}

  1263 	}

  1100 

  1264 

  1101 void CFdf::GetOtgDeviceDescriptorL(TInt aDeviceId, TOtgDescriptor& aDescriptor) const

  1265 void CFdf::GetOtgDeviceDescriptorL(TInt aDeviceId, TOtgDescriptor& aDescriptor) const

  1102 	{

  1266 	{

  1104 	

  1268 	

  1105 	DeviceProxyL(aDeviceId)->GetOtgDescriptorL(aDescriptor);

  1269 	DeviceProxyL(aDeviceId)->GetOtgDescriptorL(aDescriptor);

  1106 	}

  1271 	}

  1107 

  1272 

  1108 void CFdf::GetSerialNumberStringDescriptorL(TUint aDeviceId, TUint32 aLangId, TName& aString) const

  1273 void CFdf::GetSerialNumberStringDescriptorL(TUint aDeviceId, TUint32 aLangId, TName& aString) const

  1109 	{

  1274 	{

  1112 

  1278 

  1113 	CDeviceProxy* deviceProxy = DeviceProxyL(aDeviceId);

  1279 	CDeviceProxy* deviceProxy = DeviceProxyL(aDeviceId);

  1114 	deviceProxy->GetSerialNumberStringDescriptorL(aLangId, aString);

  1280 	deviceProxy->GetSerialNumberStringDescriptorL(aLangId, aString);

  1116 	}

  1283 	}

  1117 

  1284 

  1118 void CFdf::SearchForInterfaceFunctionDriversL(CDeviceProxy& aDevice, TBool& aAnySuccess, TInt& aCollectedErr)

  1285 void CFdf::SearchForInterfaceFunctionDriversL(CDeviceProxy& aDevice, TBool& aAnySuccess, TInt& aCollectedErr)

  1119 	{

  1286 	{

  1120 	RArray<TUint> interfacesNumberArray;	

  1287 	RArray<TUint> interfacesNumberArray;	

  1121 	CleanupClosePushL(interfacesNumberArray);

  1288 	CleanupClosePushL(interfacesNumberArray);

  1124 	

  1289 	

  1125 	for ( TUint ii = 0 ; ii < iInterfaces.Count() ; ++ii )

  1290 	for ( TUint ii = 0 ; ii < iInterfaces.Count() ; ++ii )

  1126 		{

  1291 		{

  1127 		// At this point we have NOT done any interface level searching yet,

  1292 		// At this point we have NOT done any interface level searching yet,

  1128 		// and all interfaces should in the Unclaimed status,

  1293 		// and all interfaces should in the Unclaimed status,

  1170 void CFdf::AppendInterfaceNumberToArrayL(CDeviceProxy& aDevice, RArray<TUint>& aArray, TUint aInterfaceNo) const

  1335 void CFdf::AppendInterfaceNumberToArrayL(CDeviceProxy& aDevice, RArray<TUint>& aArray, TUint aInterfaceNo) const

  1171 	{

  1336 	{

  1172 	TInt err = aArray.Append(aInterfaceNo);

  1337 	TInt err = aArray.Append(aInterfaceNo);

  1173 	if ( err )

  1338 	if ( err )

  1174 		{

  1339 		{

  1177 		}

  1343 		}

  1178 	}

  1344 	}

  1179 	

  1345 	

  1180 

  1346 

  1181 

  1347 

  1213 		CFdcProxy* fdc;

  1379 		CFdcProxy* fdc;

  1214 		while ( ( fdc = iter++ ) != NULL)

  1380 		while ( ( fdc = iter++ ) != NULL)

  1215 			{

  1381 			{

  1216 			if (fdc->MarkedForDeletion())

  1382 			if (fdc->MarkedForDeletion())

  1217 				continue;

  1383 				continue;

  1220 	// having these two together in the debug window is helpful for interactive debugging

  1386 	// having these two together in the debug window is helpful for interactive debugging

  1221 	TBuf8<KMaxSearchKeyLength> fd_key;

  1387 	TBuf8<KMaxSearchKeyLength> fd_key;

  1222 	fd_key.Append(fdc->DefaultDataField().Ptr(), fdc->DefaultDataField().Length() > KMaxSearchKeyLength ? KMaxSearchKeyLength : fdc->DefaultDataField().Length());	

  1388 	fd_key.Append(fdc->DefaultDataField().Ptr(), fdc->DefaultDataField().Length() > KMaxSearchKeyLength ? KMaxSearchKeyLength : fdc->DefaultDataField().Length());	

  1223 	TBuf8<KMaxSearchKeyLength> search_key;

  1389 	TBuf8<KMaxSearchKeyLength> search_key;

  1224 	search_key.Append(searchKeyString.Ptr(), searchKeyString.Length() > KMaxSearchKeyLength ? KMaxSearchKeyLength : searchKeyString.Length());

  1390 	search_key.Append(searchKeyString.Ptr(), searchKeyString.Length() > KMaxSearchKeyLength ? KMaxSearchKeyLength : searchKeyString.Length());

  1225 	TInt version = fdc->Version();

  1391 	TInt version = fdc->Version();

  1227 			if (searchKeyString.CompareF(fdc->DefaultDataField()) == 0)

  1393 			if (searchKeyString.CompareF(fdc->DefaultDataField()) == 0)

  1228 				{

  1394 				{

  1229 				

  1395 				

  1230 				// If there is more than one matching FD then if all of them are in RAM we simply choose the first one we find.

  1396 				// If there is more than one matching FD then if all of them are in RAM we simply choose the first one we find.

  1231 				// (Similarly if they are all in ROM we choose the first one although this situation should not arise as a device

  1397 				// (Similarly if they are all in ROM we choose the first one although this situation should not arise as a device

  1239 					{

  1405 					{

  1240 					aDevice.SetMultipleDriversFlag();

  1406 					aDevice.SetMultipleDriversFlag();

  1241 					}

  1407 					}

  1242 				

  1408 				

  1243 				foundFdc = ETrue;

  1409 				foundFdc = ETrue;

  1245 				TInt err = fdc->NewFunction(aDevice.DeviceId(), interfaces, iDD, iCD);

  1411 				TInt err = fdc->NewFunction(aDevice.DeviceId(), interfaces, iDD, iCD);

  1247 				// To correctly determine whether the driver load for the whole

  1413 				// To correctly determine whether the driver load for the whole

  1248 				// configuration was a complete failure, a partial success or a

  1414 				// configuration was a complete failure, a partial success or a

  1249 				// complete success, we need to collect any non-KErrNone error

  1415 				// complete success, we need to collect any non-KErrNone error

  1250 				// from this, and whether any handovers worked at all.

  1416 				// from this, and whether any handovers worked at all.

  1251 				if ( err == KErrNone )

  1417 				if ( err == KErrNone )

  1289 //

  1455 //

  1290 // Format the string aSearchKey according to aSearchKeys to search for Device Functions drivers

  1456 // Format the string aSearchKey according to aSearchKeys to search for Device Functions drivers

  1291 //

  1457 //

  1292 void CFdf::FormatDeviceSearchKey(TDes8& aSearchKey, TDeviceSearchKeys aDeviceSearchKeys)

  1458 void CFdf::FormatDeviceSearchKey(TDes8& aSearchKey, TDeviceSearchKeys aDeviceSearchKeys)

  1293 	{

  1459 	{

  1295 	switch (aDeviceSearchKeys)

  1462 	switch (aDeviceSearchKeys)

  1296 		{

  1463 		{

  1297 		case EVendorProductDevice:

  1464 		case EVendorProductDevice:

  1298 			{

  1465 			{

  1299 			_LIT8(KTemplateV_P_D, "V0x%04xP0x%04xD0x%04x");

  1466 			_LIT8(KTemplateV_P_D, "V0x%04xP0x%04xD0x%04x");

  1329 			_LIT8(KTemplateDC_DSC, "DC0x%02xDSC0x%02x");

  1496 			_LIT8(KTemplateDC_DSC, "DC0x%02xDSC0x%02x");