1 // Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32/drivers/usbcc/ps_usbc.cpp

    15 // Platform independent layer (PIL) of the USB Device controller driver (PDD).

    16 // Interface to the USB LDD.

    17 // 

    18 //

    19 

    20 /**

    21  @file ps_usbc.cpp

    22  @internalTechnology

    23 */

    24 

    25 #include <drivers/usbc.h>

    26 

    27 

    28 /**

    29 	TUsbcInterfaceSet and TUsbcInterface

    30 	====================================

    31 

    32 	TUsbcInterfaceSet represents a 'USB Interface' and TUsbcInterface

    33 	represents an 'Alternate Setting of a USB Interface'.

    34 

    35 	Since every LDD governs exactly one interface, the above distinction is

    36 	made only within the USB implementation. At the LDD API, there is/are

    37 	simply one or more settings for this single interface, numbered from '0'

    38 	(the default) to 'n', and specified by the parameter 'TInt aInterfaceNum'.

    39 

    40 	Within the PDD implementation, for a TUsbcInterfaceSet number the parameter

    41 	'TInt aIfcSet' is used (local variable ifcset); for a TUsbcInterface number

    42 	the parameter 'TInt aIfc' is used (local variable ifc).

    43 

    44 

    45 	iConfigs[0] and CurrentConfig()

    46 	===============================

    47 

    48 	One problem with this file is that it always uses iConfigs[0] and not

    49 	CurrentConfig(). This is mainly because the API to the LDD doesn't know

    50 	about the concept of multiple configurations, and thus always assumes one

    51 	single configuration (which is also always active: a further problem).

    52 

    53 	In the file chapter9.cpp this issue doesn't exist, since there we always

    54 	have to obey the USB protocol, and in this way will use the configuration

    55 	which is selected by the host (which will then again currently always be

    56 	iConfigs[0].)

    57 

    58 

    59 	iEp0ClientId and iEp0DataReceiving

    60 	==================================

    61 

    62 	The purpose of these two members of class DUsbClientController is the

    63 	following.

    64 

    65 	They are used only during Ep0 control transactions which have an OUT (Rx)

    66 	data stage. The special problem with these transactions is twofold. For one

    67 	thing we have to know that what we are receiving is data and not a Setup

    68 	packet. Furthermore we cannot deduce from the received data itself to whom

    69 	it is addressed (that's because of the shared nature of Ep0).

    70 

    71 	So in order to recognize data packets we use iEp0DataReceiving. This

    72 	variable is set to TRUE either 1) upon processing a standard request which

    73 	has a DATA_OUT phase (only SET_DESCRIPTOR), or 2) if we have identified a

    74 	class-specific request which has a DATA_OUT phase and we have also found

    75 	the recipient for that request.

    76 

    77 	In order to be able to tell whether received Ep0 data is to be processed by

    78 	the PIL or a LDD, we use iEp0ClientId. iEp0ClientId is usually NULL, which

    79 	means it is our data. However it is set to the client ID of an LDD in case

    80 	2) above. That way we can subsequently hand over received data to the

    81 	correct client LDD.

    82 

    83 	iEp0DataReceived tracks the amount of data already received - it is used to

    84 	determine the end of the DATA_OUT phase, irrespective of the owner of the

    85 	data. The total amount that is to be received can be obtained via

    86 	iSetup.iLength. (iSetup holds in that case the Setup packet of the current

    87 	Control transfer.)

    88 

    89 	iEp0ClientDataTransmitting is only set to TRUE if a client sets up an Ep0

    90 	write. After that transmission has completed we use this value to decide

    91 	whether we have to report the completion to a client or not. (If this

    92 	variable is FALSE, we did set up the write and thus no client notification

    93 	is necessary.)

    94 

    95 */

    96 

    97 //

    98 // === Global and Local Variables ==================================================================

    99 //

   100 

   101 GLDEF_D DUsbClientController* DUsbClientController::UsbClientController[] = {NULL, NULL};

   102 

   103 static const TInt KUsbReconnectDelay   = 500;				// milliseconds

   104 static const TInt KUsbCableStatusDelay = 500;				// milliseconds

   105 

   106 

   107 //

   108 // === USB Controller member function implementations - LDD API (public) ===========================

   109 //

   110 

   111 

   112 /** The class destructor.

   113 

   114 	This rarely gets called, except, for example when something goes

   115 	wrong during construction.

   116 

   117 	It's not exported because it is virtual.

   118 */

   119 DUsbClientController::~DUsbClientController()

   120 	{

   121 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::~DUsbClientController()"));

   122 	if (iPowerHandler)

   123 		{

   124 		iPowerHandler->Remove();

   125 		delete iPowerHandler;

   126 		}

   127 	// ResetAndDestroy() will call for every array element the destructor of the pointed-to object,

   128 	// before deleting the element itself, and closing the array.

   129 	iConfigs.ResetAndDestroy();

   130 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::~DUsbClientController(): Done."));

   131 	}

   132 

   133 

   134 /** To be called by the OTG/Host stack in an OTG setup to disable USB device

   135 	functionality.

   136 

   137 	The OTG stack calls this function when VBus is no longer valid, when the

   138 	B-device swaps out of peripheral mode, or when moving out of the

   139 	A_PERIPHERAL state.

   140 

   141 	The Client stack will disable the D+ pull-up immediately when the function

   142 	is called.

   143 

   144 	During DisableClientStack() the Client stack will notify its registered

   145 	applications on the user-side (including the USB Manager) about a USB

   146 	device state change event, a transition to the "Undefined" state.

   147 */

   148 EXPORT_C void DUsbClientController::DisableClientStack()

   149 	{

   150 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::DisableClientStack()"));

   151 	if (!iStackIsActive)

   152 		{

   153 		__KTRACE_OPT(KUSB, Kern::Printf("  Already disabled - returning"));

   154 		return;

   155 		}

   156 	iOtgClientConnect = EFalse;

   157 	TInt r = EvaluateOtgConnectFlags();					 // will disconnect UDC

   158 	if (r != KErrNone)

   159 		{

   160 		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: EvaluateOtgConnectFlags() failed: %d", r));

   161 		}

   162 

   163 	// Reset OTG features, leave attributes as is (just as in USB Reset case)

   164 	// (OTG spec 1.3 sections 6.5.x all say "... on a bus reset or at the end

   165 	//  of a session." VBus drop is the end of a session.)

   166 	iOtgFuncMap &= KUsbOtgAttr_SrpSupp | KUsbOtgAttr_HnpSupp;

   167 	OtgFeaturesNotify();

   168 	// Tear down the current configuration (if any)

   169 	ChangeConfiguration(0);

   170 

   171 	if (iDeviceState != EUsbcDeviceStateUndefined)

   172 		{

   173 		// Not being in state UNDEFINED implies that the cable is inserted.

   174 		if (iHardwareActivated)

   175 			{

   176 			NextDeviceState(EUsbcDeviceStatePowered);

   177 			}

   178 		// (If the hardware is NOT activated at this point, we can only be in

   179 		//	state EUsbcDeviceStateAttached, so we don't have to move to it.)

   180 		}

   181 	DeActivateHardwareController();					 // turn off UDC altogether

   182 	iStackIsActive = EFalse;

   183 	// Complete all pending requests, returning KErrDisconnected

   184 	RunClientCallbacks();

   185 	// Notify registered clients on the user side about a USB device state

   186 	// change event and a transition to the "Undefined" state.

   187 	NextDeviceState(EUsbcDeviceStateUndefined);

   188 	}

   189 

   190 

   191 /** To be called by the OTG/Host stack in an OTG setup to enable USB device

   192 	functionality.

   193 

   194 	Once called, the function will return quickly, but it will by then not

   195 	necessarily have enabled the D+ pull-up*. The Client stack can enable the D+

   196 	pull-up (via the transceiver) from that moment on and as long as the OTG

   197 	stack doesn't call DisableClientStack().

   198 

   199 	*) It will enable the D+ pull-up immediately if the user-side USB support

   200 	has already been loaded. This should always be the case when the OTG stack

   201 	is calling this function during the transition to the A_PERIPHERAL state,

   202 	i.e. when acting as an A-device.

   203 */

   204 EXPORT_C void DUsbClientController::EnableClientStack()

   205 	{

   206 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::EnableClientStack()"));

   207 	if (iStackIsActive)

   208 		{

   209 		__KTRACE_OPT(KUSB, Kern::Printf("  Already enabled - returning"));

   210 		return;

   211 		}

   212 	iStackIsActive = ETrue;

   213 	// If the UDC is still off, we switch it on here.

   214 	TInt r = ActivateHardwareController();

   215 	if (r != KErrNone)

   216 		{

   217 		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: ActivateHardwareController() failed: %d", r));

   218 		}

   219 	iOtgClientConnect = ETrue;

   220 	r = EvaluateOtgConnectFlags();							// may connect UDC

   221 	if (r != KErrNone)

   222 		{

   223 		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: EvaluateOtgConnectFlags() failed: %d", r));

   224 		}

   225 	}

   226 

   227 

   228 /** Called by LDD to see if controller is usable.

   229 

   230 	@return ETrue if controller is in normal state, EFalse if it is disabled.

   231 */

   232 EXPORT_C TBool DUsbClientController::IsActive()

   233 	{

   234 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::IsActive()"));

   235 	return iStackIsActive;

   236 	}

   237 

   238 

   239 /** Called by LDD to register client callbacks.

   240 

   241 	@return KErrNone if successful, KErrAlreadyExists callback exists.

   242 */

   243 EXPORT_C TInt DUsbClientController::RegisterClientCallback(TUsbcClientCallback& aCallback)

   244 	{

   245 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::RegisterClientCallback()"));

   246 	if (iClientCallbacks.Elements() == KUsbcMaxListLength)

   247 		{

   248 		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Maximum list length reached: %d",

   249 										  KUsbcMaxListLength));

   250 		return KErrGeneral;

   251 		}

   252 	TSglQueIter<TUsbcClientCallback> iter(iClientCallbacks);

   253 	TUsbcClientCallback* p;

   254 	while ((p = iter++) != NULL)

   255 		if (p == &aCallback)

   256 			{

   257 			__KTRACE_OPT(KUSB, Kern::Printf("	 Error: ClientCallback @ 0x%x already registered", &aCallback));

   258 			return KErrAlreadyExists;

   259 			}

   260 	iClientCallbacks.AddLast(aCallback);

   261 	return KErrNone;

   262 	}

   263 

   264 

   265 /** Returns a pointer to the USB client controller object.

   266 

   267 	This function is static.

   268 

   269 	@param aUdc The number of the UDC (0..n) for which the pointer is to be returned.

   270 

   271 	@return A pointer to the USB client controller object.

   272 */

   273 EXPORT_C DUsbClientController* DUsbClientController::UsbcControllerPointer(TInt aUdc)

   274 	{

   275 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::UsbcControllerPointer()"));

   276 	if (aUdc < 0 || aUdc > 1)

   277 		{

   278 		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: aUdc out of range (%d)", aUdc));

   279 		return NULL;

   280 		}

   281 	return UsbClientController[aUdc];

   282 	}

   283 

   284 

   285 /** Fills the buffer passed in as an argument with endpoint capability information.

   286 

   287  	@see DUsbClientController::DeviceCaps()

   288 	@see TUsbcEndpointData

   289 	@see TUsbDeviceCaps

   290 

   291 	@param aClientId A pointer to the LDD making the enquiry.

   292 	@param aCapsBuf A reference to a descriptor buffer, which, on return, contains an array of

   293 	TUsbcEndpointData elements; there are TUsbDeviceCaps::iTotalEndpoints elements in the array;

   294 	call DeviceCaps() to get the number of elements required.

   295 */

   296 EXPORT_C void DUsbClientController::EndpointCaps(const DBase* aClientId, TDes8& aCapsBuf) const

   297 	{

   298 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::EndpointCaps()"));

   299 	// Here we do not simply call DUsbClientController::DeviceEndpointCaps(),

   300 	// because that function fills an array which comprises of _all_ endpoints,

   301 	// whereas this function omits ep0 and all unusable endpoints.

   302 	// Apart from that, we have to fill an array of TUsbcEndpointData, not TUsbcEndpointCaps.

   303 	TUsbcEndpointData data[KUsbcMaxEndpoints];

   304 	const TInt ifcset_num = ClientId2InterfaceNumber(aClientId);

   305 	for (TInt i = 2, j = 0; i < iDeviceTotalEndpoints; ++i)

   306 		{

   307 		__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::Caps: RealEndpoint #%d", i));

   308 		if (iRealEndpoints[i].iCaps.iTypesAndDir != KUsbEpNotAvailable)

   309 			{

   310 			__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::Caps: --> UsableEndpoint #%d", j));

   311 			data[j].iCaps = iRealEndpoints[i].iCaps;

   312 			if (ifcset_num < 0)

   313 				{

   314 				// If this LDD doesn't own an interface, but the Ep points to one,

   315 				// then that must be the interface of a different LDD. Hence the Ep

   316 				// is not available for this LDD.

   317 				data[j].iInUse = (iRealEndpoints[i].iIfcNumber != NULL);

   318 				}

   319 			else

   320 				{

   321 				// If this LDD does already own an interface, and the Ep also points to one,

   322 				// then the Ep is not available for this LDD only if that interface is owned

   323 				// by a different LDD (i.e. if the interface number is different).

   324 				// Reason: Even though the endpoint might already be part of an interface setting,

   325 				// it is still available for a different alternate setting of the same interface.

   326 				data[j].iInUse = ((iRealEndpoints[i].iIfcNumber != NULL) &&

   327 								  (*(iRealEndpoints[i].iIfcNumber) != ifcset_num));

   328 				}

   329 			j++;

   330 			}

   331 		}

   332 	// aCapsBuf resides in userland

   333 	TPtrC8 des((TUint8*)data, sizeof(data));

   334 	const TInt r = Kern::ThreadDesWrite((reinterpret_cast<const DLddUsbcChannel*>(aClientId))->Client(),

   335 										&aCapsBuf, des, 0, KChunkShiftBy0, NULL);

   336 	if (r != KErrNone)

   337 		{

   338 		Kern::ThreadKill((reinterpret_cast<const DLddUsbcChannel*>(aClientId))->Client(),

   339 						 EExitPanic, r, KUsbPILKillCat);

   340 		}

   341 	}

   342 

   343 

   344 /** Fills the buffer passed in as an argument with device capability information.

   345 

   346 	@see TUsbDeviceCaps

   347 	@see TUsbDeviceCapsV01

   348 

   349 	@param aClientId A pointer to the LDD making the enquiry.

   350 	@param aCapsBuf A reference to a descriptor buffer which, on return, contains

   351 	a TUsbDeviceCaps structure.

   352 */

   353 EXPORT_C void DUsbClientController::DeviceCaps(const DBase* aClientId, TDes8& aCapsBuf) const

   354 	{

   355 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::DeviceCaps()"));

   356 	TUsbDeviceCaps caps;

   357 	caps().iTotalEndpoints = iDeviceUsableEndpoints;		// not DeviceTotalEndpoints()!

   358 	caps().iConnect = SoftConnectCaps();

   359 	caps().iSelfPowered = iSelfPowered;

   360 	caps().iRemoteWakeup = iRemoteWakeup;

   361 	caps().iHighSpeed = DeviceHighSpeedCaps();

   362 	caps().iFeatureWord1 = CableDetectWithoutPowerCaps() ?

   363 		caps().iFeatureWord1 | KUsbDevCapsFeatureWord1_CableDetectWithoutPower :

   364 		caps().iFeatureWord1 & ~KUsbDevCapsFeatureWord1_CableDetectWithoutPower;

   365 	caps().iFeatureWord1 = DeviceResourceAllocV2Caps() ?

   366 		caps().iFeatureWord1 | KUsbDevCapsFeatureWord1_EndpointResourceAllocV2 :

   367 		caps().iFeatureWord1 & ~KUsbDevCapsFeatureWord1_EndpointResourceAllocV2;

   368 	caps().iReserved = 0;

   369 

   370 	// aCapsBuf resides in userland

   371 	const TInt r = Kern::ThreadDesWrite((reinterpret_cast<const DLddUsbcChannel*>(aClientId))->Client(),

   372 										&aCapsBuf, caps, 0, KChunkShiftBy0, NULL);

   373 	if (r != KErrNone)

   374 		{

   375 		Kern::ThreadKill((reinterpret_cast<const DLddUsbcChannel*>(aClientId))->Client(),

   376 						 EExitPanic, r, KUsbPILKillCat);

   377 		}

   378 	}

   379 

   380 

   381 TUsbcEndpointInfoArray::TUsbcEndpointInfoArray(const TUsbcEndpointInfo* aData, TInt aDataSize)

   382 	{

   383 	iType = EUsbcEndpointInfo;

   384 	iData = (TUint8*) aData;

   385 	if (aDataSize > 0)

   386 		iDataSize = aDataSize;

   387 	else

   388 		iDataSize = sizeof(TUsbcEndpointInfo);

   389 	}

   390 

   391 

   392 inline TUsbcEndpointInfo& TUsbcEndpointInfoArray::operator[](TInt aIndex) const

   393 	{

   394 	return *(TUsbcEndpointInfo*) &iData[aIndex * iDataSize];

   395 	}

   396 

   397 

   398 EXPORT_C TInt DUsbClientController::SetInterface(const DBase* aClientId, DThread* aThread,

   399 												 TInt aInterfaceNum, TUsbcClassInfo& aClass,

   400 												 TDesC8* aString, TInt aTotalEndpointsUsed,

   401 												 const TUsbcEndpointInfo aEndpointData[],

   402 												 TInt (*aRealEpNumbers)[6], TUint32 aFeatureWord)

   403 	{

   404 	TUsbcEndpointInfoArray endpointData = TUsbcEndpointInfoArray(aEndpointData);

   405 	return SetInterface(aClientId, aThread, aInterfaceNum, aClass, aString, aTotalEndpointsUsed,

   406 						endpointData, (TInt*) aRealEpNumbers, aFeatureWord);

   407 	}

   408 

   409 

   410 /** Creates a new USB interface (one setting), complete with endpoints, descriptors, etc.,

   411 	and chains it into the internal device configuration tree.

   412 

   413 	@param aClientId A pointer to the LDD owning the new interface.

   414 	@param aThread A pointer to the thread the owning LDD is running in.

   415 	@param aInterfaceNum The interface setting number of the new interface setting. This must be 0

   416 	if it is the first setting of the interface that gets created, or 1 more than the last setting

   417 	that was created for this interface.

   418 	@param aClass Contains information about the device class this interface might belong to.

   419 	@param aString A pointer to a string that is used for the string descriptor of this interface.

   420 	@param aTotalEndpointsUsed The number of endpoints used by this interface (and also the number of

   421 	elements of the following array).

   422 	@param aEndpointData An array with aTotalEndpointsUsed elements, containing information about the

   423 	endpoints of this interface.

   424 

   425 	@return KErrNotSupported if Control endpoints are requested by the LDD but aren't supported by the PIL,

   426 	KErrInUse if at least one requested endpoint is - temporarily or permanently - not available for use,

   427 	KErrNoMemory if (endpoint, interface, string) descriptor allocation fails, KErrGeneral if something else

   428 	goes wrong during endpoint or interface or descriptor creation, KErrNone if interface successfully set up.

   429 */

   430 EXPORT_C TInt DUsbClientController::SetInterface(const DBase* aClientId, DThread* aThread,

   431 												 TInt aInterfaceNum, TUsbcClassInfo& aClass,

   432 												 TDesC8* aString, TInt aTotalEndpointsUsed,

   433 												 const TUsbcEndpointInfoArray aEndpointData,

   434 												 TInt aRealEpNumbers[], TUint32 aFeatureWord)

   435 	{

   436 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::SetInterface()"));

   437 	if (aInterfaceNum != 0)

   438 		{

   439 		__KTRACE_OPT(KUSB, Kern::Printf("  alternate interface setting request: #%d", aInterfaceNum));

   440 		}

   441 #ifndef USB_SUPPORTS_CONTROLENDPOINTS

   442 	for (TInt i = 0; i < aTotalEndpointsUsed; ++i)

   443 		{

   444 		if (aEndpointData[i].iType == KUsbEpTypeControl)

   445 			{

   446 			__KTRACE_OPT(KPANIC, Kern::Printf("  Error: control endpoints not supported"));

   447 			return KErrNotSupported;

   448 			}

   449 		}

   450 #endif

   451 	// Check for endpoint availability & check those endpoint's capabilities

   452 	const TInt ifcset_num = ClientId2InterfaceNumber(aClientId);

   453 	// The passed-in ifcset_num may be -1 now, but that's intended.

   454 	if (!CheckEpAvailability(aTotalEndpointsUsed, aEndpointData, ifcset_num))

   455 		{

   456 		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: endpoints not (all) available"));

   457 		return KErrInUse;

   458 		}

   459 	// Create & setup new interface

   460 	TUsbcInterface* ifc = CreateInterface(aClientId, aInterfaceNum, aFeatureWord);

   461 	if (ifc == NULL)

   462 		{

   463 		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: ifc == NULL"));

   464 		return KErrGeneral;

   465 		}

   466 	// Create logical endpoints

   467 	TInt r = CreateEndpoints(ifc, aTotalEndpointsUsed, aEndpointData, aRealEpNumbers);

   468 	if (r != KErrNone)

   469 		{

   470 		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: CreateEndpoints() != KErrNone"));

   471 		DeleteInterface(ifc->iInterfaceSet->iInterfaceNumber, aInterfaceNum);

   472 		return r;

   473 		}

   474 	// Create & setup interface, string, and endpoint descriptors

   475 	r = SetupIfcDescriptor(ifc, aClass, aThread, aString, aEndpointData);

   476 	if (r != KErrNone)

   477 		{

   478 		return r;

   479 		}

   480 	return KErrNone;

   481 	}

   482 

   483 

   484 /** Releases an existing USB interface (one setting), complete with endpoints, descriptors, etc.,

   485 	and removes it from the internal device configuration tree.

   486 

   487 	@param aClientId A pointer to the LDD owning the interface.

   488 	@param aInterfaceNum The setting number of the interface setting to be deleted. This must be

   489 	the highest numbered (or 'last') setting for this interface.

   490 

   491 	@return KErrNotFound if interface (not setting) for some reason cannot be found, KErrArgument if an

   492 	invalid interface setting number is specified (not existing or existing but too small), KErrNone if

   493 	interface successfully released or if this client doesn't own any interface.

   494 */

   495 EXPORT_C TInt DUsbClientController::ReleaseInterface(const DBase* aClientId, TInt aInterfaceNum)

   496 	{

   497 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::ReleaseInterface(..., %d)", aInterfaceNum));

   498 	const TInt ifcset = ClientId2InterfaceNumber(aClientId);

   499 	if (ifcset < 0)

   500 		{

   501 		__KTRACE_OPT(KUSB, Kern::Printf(" interface not found")); // no error

   502 		return KErrNone;

   503 		}

   504 	TUsbcInterfaceSet* const ifcset_ptr = InterfaceNumber2InterfacePointer(ifcset);

   505 	if (!ifcset_ptr)

   506 		{

   507 		__KTRACE_OPT(KUSB, Kern::Printf(" Error: interface number %d doesn't exist", ifcset));

   508 		return KErrNotFound;

   509 		}

   510 	const TInt setting_count = ifcset_ptr->iInterfaces.Count();

   511 	if ((setting_count - 1) != aInterfaceNum)

   512 		{

   513 		__KTRACE_OPT(KUSB,

   514 					 Kern::Printf(" > Error: interface settings must be released in descending order:\n\r"

   515 								  "   %d setting(s) exist, #%d was requested to be released.\n\r"

   516 								  "   (#%d has to be released first)",

   517 								  setting_count, aInterfaceNum, setting_count - 1));

   518 		return KErrArgument;

   519 		}

   520 	// Tear down current setting (invalidate configured state)

   521 	__KTRACE_OPT(KUSB, Kern::Printf(" > tearing down InterfaceSet %d", ifcset));

   522 	// Cancel all transfers on the current setting of this interface and deconfigure all its endpoints.

   523 	InterfaceSetTeardown(ifcset_ptr);

   524 	// 'Setting 0' means: delete all existing settings.

   525 	if (aInterfaceNum == 0)

   526 		{

   527 		TInt m = ifcset_ptr->iInterfaces.Count();

   528 		while (m > 0)

   529 			{

   530 			m--;

   531 			// Ground the physical endpoints' logical_endpoint_pointers

   532 			const TInt n = ifcset_ptr->iInterfaces[m]->iEndpoints.Count();

   533 			for (TInt i = 0; i < n; ++i)

   534 				{

   535 				TUsbcPhysicalEndpoint* ptr = const_cast<TUsbcPhysicalEndpoint*>

   536 					(ifcset_ptr->iInterfaces[m]->iEndpoints[i]->iPEndpoint);

   537 				ptr->iLEndpoint = NULL;

   538 				}

   539 			// Delete the setting itself + its ifc & ep descriptors

   540 			DeleteInterface(ifcset, m);

   541 			iDescriptors.DeleteIfcDescriptor(ifcset, m);

   542 			}

   543 		}

   544 	else

   545 		{

   546 		// Ground the physical endpoints' logical_endpoint_pointers

   547 		const TInt n = ifcset_ptr->iInterfaces[aInterfaceNum]->iEndpoints.Count();

   548 		for (TInt i = 0; i < n; ++i)

   549 			{

   550 			TUsbcPhysicalEndpoint* ptr = const_cast<TUsbcPhysicalEndpoint*>

   551 				(ifcset_ptr->iInterfaces[aInterfaceNum]->iEndpoints[i]->iPEndpoint);

   552 			ptr->iLEndpoint = NULL;

   553 			}

   554 		// Delete the setting itself + its ifc & ep descriptors

   555 		DeleteInterface(ifcset, aInterfaceNum);

   556 		iDescriptors.DeleteIfcDescriptor(ifcset, aInterfaceNum);

   557 		}

   558 	// Delete the whole interface if all settings are gone

   559 	if (ifcset_ptr->iInterfaces.Count() == 0)

   560 		{

   561 		DeleteInterfaceSet(ifcset);

   562 		}

   563 	// We now no longer have a valid current configuration

   564 	iCurrentConfig = 0;

   565 	if (iDeviceState == EUsbcDeviceStateConfigured)

   566 		{

   567 		NextDeviceState(EUsbcDeviceStateAddress);

   568 		}

   569 	// If it was the last interface(set)...

   570 	if (iConfigs[0]->iInterfaceSets.Count() == 0)

   571 		{

   572 		__KTRACE_OPT(KUSB, Kern::Printf("  No ifc left -> turning off UDC"));

   573 		// First disconnect the device from the bus

   574 		UsbDisconnect();

   575 		DeActivateHardwareController();

   576 		// (this also disables endpoint zero; we cannot have a USB device w/o interface, see 9.6.3)

   577 		}

   578 	return KErrNone;

   579 	}

   580 

   581 

   582 /** Enforces a USB re-enumeration by disconnecting the UDC from the bus (if it is currently connected) and

   583 	re-connecting it.

   584 

   585 	This only works if the PSL supports it, i.e. if SoftConnectCaps() returns ETrue.

   586 */

   587 EXPORT_C TInt DUsbClientController::ReEnumerate()

   588 	{

   589 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::ReEnumerate()"));

   590 	// If, in an OTG setup, the client stack is disabled, there's no point in

   591 	// trying to reenumerate the device. In fact, we then don't even want to

   592 	// turn on the UDC via ActivateHardwareController().

   593 	if (!iStackIsActive)

   594 		{

   595 		__KTRACE_OPT(KUSB, Kern::Printf("  Client stack disabled -> returning here"));

   596 		return KErrNotReady;

   597 		}

   598 	// We probably don't check here whether SoftConnectCaps() is ETrue, and

   599 	// return if not, because we might still want to execute

   600 	// ActivateHardwareController(). UsbConnect() and UsbDisconnect() should be

   601 	// no-ops if not supported by the PSL.

   602 	if (iConfigs[0]->iInterfaceSets.Count() == 0)

   603 		{

   604 		__KTRACE_OPT(KUSB, Kern::Printf("  > No interface registered -> no need to re-enumerate"));

   605 		return KErrNone;;

   606 		}

   607 	if (!iHardwareActivated)

   608 		{

   609 		// If the UDC is still off, we switch it on here.

   610 		const TInt r = ActivateHardwareController();

   611 		if (r != KErrNone)

   612 				{

   613 				__KTRACE_OPT(KPANIC, Kern::Printf("  Error: ActivateHardwareController() failed: %d", r));

   614 				return r;

   615 				}

   616 		// Finally connect the device to the bus

   617 		UsbConnect();

   618 		}

   619 	else

   620 		{

   621 		UsbDisconnect();

   622 		// Now we have to wait a certain amount of time, in order to give the host the opportunity

   623 		// to come to terms with the new situation.

   624 		// (The ETrue parameter makes the callback get called in DFC instead of in ISR context.)

   625 		iReconnectTimer.OneShot(KUsbReconnectDelay, ETrue);

   626 		}

   627 	return KErrNone;;

   628 	}

   629 

   630 

   631 /** Powers up the UDC if one or more interfaces exist.

   632 

   633 	@return KErrNone if UDC successfully powered up, KErrNotReady if no

   634 	interfaces have been registered yet, KErrHardwareNotAvailable if UDC

   635 	couldn't be activated.

   636 */

   637 EXPORT_C TInt DUsbClientController::PowerUpUdc()

   638 	{

   639 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::PowerUpUdc()"));

   640 	// If, in an OTG setup, the client stack is disabled, we mustn't turn on

   641 	// the UDC via ActivateHardwareController() as that would already configure

   642 	// Ep0.

   643 	if (!iStackIsActive)

   644 		{

   645 		__KTRACE_OPT(KUSB, Kern::Printf("  Client stack disabled -> returning here"));

   646 		return KErrNotReady;

   647 		}

   648 	if (iConfigs[0]->iInterfaceSets.Count() == 0)

   649 		{

   650 		__KTRACE_OPT(KUSB, Kern::Printf("  > No interface registered -> won't power up UDC"));

   651 		return KErrNotReady;

   652 		}

   653 	// If the UDC is still off, we switch it on here.

   654 	const TInt r = ActivateHardwareController();

   655 	if (r != KErrNone)

   656 		{

   657 		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: ActivateHardwareController() failed: %d", r));

   658 		}

   659 	return r;

   660 	}

   661 

   662 

   663 /** Connects the UDC to the bus.

   664 

   665 	This only works if the PSL supports it, i.e. if SoftConnectCaps() returns ETrue.

   666 

   667 	@return KErrNone if UDC successfully connected, KErrGeneral if there was an error.

   668 */

   669 EXPORT_C TInt DUsbClientController::UsbConnect()

   670 	{

   671 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::UsbConnect()"));

   672 #ifdef USB_OTG_CLIENT

   673 	iClientSupportReady = ETrue;

   674 	const TInt r = EvaluateOtgConnectFlags();

   675 	const TInt irq = NKern::DisableAllInterrupts();

   676 	if (iUsbResetDeferred) // implies (iOtgHnpHandledByHw == ETrue)

   677 		{

   678 		__KTRACE_OPT(KUSB, Kern::Printf("  Resetting USB Reset 'defer' flag"));

   679 		iUsbResetDeferred = EFalse;

   680 		(void) ProcessResetEvent(EFalse);

   681 		}

   682 	NKern::RestoreInterrupts(irq);

   683 #else

   684 	const TInt r = UdcConnect();

   685 #endif // USB_OTG_CLIENT

   686 	return r;

   687 	}

   688 

   689 

   690 /** Disconnects the UDC from the bus.

   691 

   692 	This only works if the PSL supports it, i.e. if SoftConnectCaps() returns ETrue.

   693 

   694 	@return KErrNone if UDC successfully disconnected, KErrGeneral if there was an error.

   695 */

   696 EXPORT_C TInt DUsbClientController::UsbDisconnect()

   697 	{

   698 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::UsbDisconnect()"));

   699 #ifdef USB_OTG_CLIENT

   700 	iClientSupportReady = EFalse;

   701 	const TInt r = EvaluateOtgConnectFlags();

   702 #else

   703 	const TInt r = UdcDisconnect();

   704 #endif // USB_OTG_CLIENT

   705 	// There won't be any notification by the PSL about this,

   706 	// so we have to notify the LDD/user ourselves:

   707 	if ((r == KErrNone) && (iDeviceState != EUsbcDeviceStateUndefined))

   708 		{

   709 		// Not being in state UNDEFINED implies that the cable is inserted.

   710 		if (iHardwareActivated)

   711 			{

   712 			NextDeviceState(EUsbcDeviceStatePowered);

   713 			}

   714 		// (If the hardware is NOT activated at this point, we can only be in

   715 		//	state EUsbcDeviceStateAttached, so we don't have to move to it.)

   716 		}

   717 	return r;

   718 	}

   719 

   720 

   721 /** Registers a notification callback for changes of the USB device state.

   722 

   723 	In the event of a device state change, the callback's state member gets updated (using SetState) with a

   724 	new TUsbcDeviceState value, and then the callback is executed (DoCallback). 'USB device state' here refers

   725 	to the Visible Device States as defined in chapter 9 of the USB specification.

   726 

   727 	@param aCallback A reference to a properly filled in status callback structure.

   728 

   729 	@return KErrNone if callback successfully registered, KErrGeneral if this callback is already registered

   730 	(it won't be registered twice).

   731 */

   732 EXPORT_C TInt DUsbClientController::RegisterForStatusChange(TUsbcStatusCallback& aCallback)

   733 	{

   734 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::RegisterForStatusChange()"));

   735 	if (iStatusCallbacks.Elements() == KUsbcMaxListLength)

   736 		{

   737 		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Maximum list length reached: %d",

   738 										  KUsbcMaxListLength));

   739 		return KErrGeneral;

   740 		}

   741 	if (IsInTheStatusList(aCallback))

   742 		{

   743 		__KTRACE_OPT(KUSB, Kern::Printf("  Error: StatusCallback @ 0x%x already registered", &aCallback));

   744 		return KErrGeneral;

   745 		}

   746 	const TInt irq = NKern::DisableAllInterrupts();

   747 	iStatusCallbacks.AddLast(aCallback);

   748 	NKern::RestoreInterrupts(irq);

   749 	return KErrNone;

   750 	}

   751 

   752 

   753 /** De-registers (removes from the list of pending requests) a notification callback for the USB device

   754 	status.

   755 

   756 	@param aClientId A pointer to the LDD owning the status change callback.

   757 

   758 	@return KErrNone if callback successfully unregistered, KErrNotFound if the callback couldn't be found.

   759 */

   760 EXPORT_C TInt DUsbClientController::DeRegisterForStatusChange(const DBase* aClientId)

   761 	{

   762 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::DeRegisterForStatusChange()"));

   763 	__ASSERT_DEBUG((aClientId != NULL), Kern::Fault(KUsbPILPanicCat, __LINE__));

   764 	const TInt irq = NKern::DisableAllInterrupts();

   765 	TSglQueIter<TUsbcStatusCallback> iter(iStatusCallbacks);

   766 	TUsbcStatusCallback* p;

   767 	while ((p = iter++) != NULL)

   768 		{

   769 		if (p->Owner() == aClientId)

   770 			{

   771 			__KTRACE_OPT(KUSB, Kern::Printf("  removing StatusCallback @ 0x%x", p));

   772 			iStatusCallbacks.Remove(*p);

   773 			NKern::RestoreInterrupts(irq);

   774 			return KErrNone;

   775 			}

   776 		}

   777 	__KTRACE_OPT(KUSB, Kern::Printf("  client not found"));

   778 	NKern::RestoreInterrupts(irq);

   779 	return KErrNotFound;

   780 	}

   781 

   782 

   783 /** Registers a notification callback for changes of the state of endpoints.

   784 

   785 	In the event of a state change of an endpoint that is spart of an interface which is owned by the LDD

   786 	specified in the callback structure, the callback's state member gets updated (using SetState) with a new

   787 	value, and the callback is executed (DoCallback). 'Endpoint state' here refers to the state of the

   788 	ENDPOINT_HALT feature of an endpoint as described in chapter 9 of the USB specification. The contents of

   789 	the state variable reflects the state of the halt features for all endpoints of the current interface

   790 	setting: bit 0 represents endpoint 1, bit 1 endpoint 2, etc. A set bit means 'endpoint halted', a cleared

   791 	bit 'endpoint not halted'.

   792 

   793 	@param aCallback A reference to a properly filled in endpoint status callback structure.

   794 

   795 	@return KErrNone if callback successfully registered, KErrGeneral if this callback is already registered

   796 	(it won't be registered twice).

   797 */

   798 EXPORT_C TInt DUsbClientController::RegisterForEndpointStatusChange(TUsbcEndpointStatusCallback& aCallback)

   799 	{

   800 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::RegisterForEndpointStatusChange()"));

   801 	if (iEpStatusCallbacks.Elements() == KUsbcMaxListLength)

   802 		{

   803 		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Maximum list length reached: %d",

   804 										  KUsbcMaxListLength));

   805 		return KErrGeneral;

   806 		}

   807 	if (IsInTheEpStatusList(aCallback))

   808 		{

   809 		__KTRACE_OPT(KUSB, Kern::Printf("  Error: EpStatusCallback @ 0x%x already registered", &aCallback));

   810 		return KErrGeneral;

   811 		}

   812 	const TInt irq = NKern::DisableAllInterrupts();

   813 	iEpStatusCallbacks.AddLast(aCallback);

   814 	NKern::RestoreInterrupts(irq);

   815 	return KErrNone;

   816 	}

   817 

   818 

   819 /** De-registers (removes from the list of pending requests) a notification callback for changes of the state

   820 	of endpoints.

   821 

   822 	@param aClientId A pointer to the LDD owning the endpoint status change callback.

   823 

   824 	@return KErrNone if callback successfully unregistered, KErrNotFound if the callback couldn't be found.

   825 */

   826 EXPORT_C TInt DUsbClientController::DeRegisterForEndpointStatusChange(const DBase* aClientId)

   827 	{

   828 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::DeRegisterForEndpointStatusChange()"));

   829 	__ASSERT_DEBUG((aClientId != NULL), Kern::Fault(KUsbPILPanicCat, __LINE__));

   830 	const TInt irq = NKern::DisableAllInterrupts();

   831 	TSglQueIter<TUsbcEndpointStatusCallback> iter(iEpStatusCallbacks);

   832 	TUsbcEndpointStatusCallback* p;

   833 	while ((p = iter++) != NULL)

   834 		{

   835 		if (p->Owner() == aClientId)

   836 			{

   837 			__KTRACE_OPT(KUSB, Kern::Printf("  removing EpStatusCallback @ 0x%x", p));

   838 			iEpStatusCallbacks.Remove(*p);

   839 			NKern::RestoreInterrupts(irq);

   840 			return KErrNone;

   841 			}

   842 		}

   843 	__KTRACE_OPT(KUSB, Kern::Printf("  client not found"));

   844 	NKern::RestoreInterrupts(irq);

   845 	return KErrNotFound;

   846 	}

   847 

   848 

   849 /** Returns the number of the currently active alternate interface setting for this interface.

   850 

   851 	@param aClientId A pointer to the LDD owning the interface.

   852 	@param aInterfaceNum Here the interface gets written to.

   853 

   854 	@return KErrNotFound if an interface for this client couldn't be found, KErrNone if setting value was

   855 	successfully written.

   856 */

   857 EXPORT_C TInt DUsbClientController::GetInterfaceNumber(const DBase* aClientId, TInt& aInterfaceNum) const

   858 	{

   859 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::GetInterfaceNumber()"));

   860 	const TInt ifcset = ClientId2InterfaceNumber(aClientId);

   861 	if (ifcset < 0)

   862 		{

   863 		__KTRACE_OPT(KPANIC, Kern::Printf("  Error (ifc < 0)"));

   864 		return KErrNotFound;

   865 		}

   866 	const TUsbcInterfaceSet* const ifcset_ptr = InterfaceNumber2InterfacePointer(ifcset);

   867 	if (!ifcset_ptr)

   868 		{

   869 		__KTRACE_OPT(KPANIC, Kern::Printf("  Error: interface number %d doesn't exist", ifcset));

   870 		return KErrNotFound;

   871 		}

   872 	aInterfaceNum = ifcset_ptr->iCurrentInterface;

   873 	return KErrNone;

   874 	}

   875 

   876 

   877 /** This is normally called once by an LDD's destructor, either after a Close() on the user side,

   878 	or during general cleanup.

   879 

   880 	It might also be called by the LDD when some internal unrecoverable error occurs.

   881 

   882 	This function

   883 	- de-registers a possibly pending device state change notification request,

   884 	- de-registers a possibly pending endpoint state change notification request,

   885 	- releases all interfaces + settings owned by this LDD,

   886 	- cancels all remaining (if any) read/write requests.

   887 

   888 	@param aClientId A pointer to the LDD to be unregistered.

   889 

   890 	@return KErrNone.

   891 */

   892 EXPORT_C TInt DUsbClientController::DeRegisterClient(const DBase* aClientId)

   893 	{

   894 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::DeRegisterClient(0x%x)", aClientId));

   895 	// Cancel all device state notification requests

   896 	DeRegisterForStatusChange(aClientId);

   897 	// Cancel all endpoint state notification requests

   898 	DeRegisterForEndpointStatusChange(aClientId);

   899 	DeRegisterForOtgFeatureChange(aClientId);

   900 	DeRegisterClientCallback(aClientId);

   901 	// Delete the interface including all its alternate settings which might exist.

   902 	// (If we release the default setting (0), all alternate settings are deleted as well.)

   903 	const TInt r = ReleaseInterface(aClientId, 0);

   904 	// Cancel all remaining (if any) read/write requests

   905 	DeleteRequestCallbacks(aClientId);

   906 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::DeRegisterClient: Done."));

   907 	return r;

   908 	}

   909 

   910 

   911 /** Returns the currently used Ep0 max packet size.

   912 

   913 	@return The currently used Ep0 max packet size.

   914 */

   915 EXPORT_C TInt DUsbClientController::Ep0PacketSize() const

   916 	{

   917 	const TUsbcLogicalEndpoint* const ep = iRealEndpoints[0].iLEndpoint;

   918 	if (iHighSpeed)

   919 		{

   920 		__KTRACE_OPT(KUSB, Kern::Printf("  Ep0 size = %d (HS)", ep->iEpSize_Hs));

   921 		return ep->iEpSize_Hs;

   922 		}

   923 	else

   924 		{

   925 		__KTRACE_OPT(KUSB, Kern::Printf("  Ep0 size = %d (FS)", ep->iEpSize_Fs));

   926 		return ep->iEpSize_Fs;

   927 		}

   928 	}

   929 

   930 

   931 /** Stalls Ep0.

   932 

   933 	@param aClientId A pointer to the LDD wishing to stall Ep0 (this is for PIL internal purposes only).

   934 

   935 	@return KErrNone if endpoint zero successfully stalled, KErrGeneral otherwise.

   936 */

   937 EXPORT_C TInt DUsbClientController::Ep0Stall(const DBase* aClientId)

   938 	{

   939 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::Ep0Stall()"));

   940 	if (aClientId == iEp0ClientId)

   941 		{

   942 		ResetEp0DataOutVars();

   943 		}

   944 	const TInt err = StallEndpoint(KEp0_Out);

   945 	if (err < 0)

   946 		{

   947 		return err;

   948 		}

   949 	else

   950 		return StallEndpoint(KEp0_In);

   951 	}

   952 

   953 

   954 /** Sends a zero-byte status packet on Ep0.

   955 

   956 	@param aClientId A pointer to the LDD wishing to send the status packet (not used at present).

   957 */

   958 EXPORT_C void DUsbClientController::SendEp0StatusPacket(const DBase* /* aClientId */)

   959 	{

   960 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::SendEp0StatusPacket()"));

   961 	SendEp0ZeroByteStatusPacket();

   962 	}

   963 

   964 

   965 /** Returns the current USB device state.

   966 

   967 	'USB device state' here refers to the Visible Device States as defined in chapter 9 of the USB

   968 	specification.

   969 

   970 	@return The current USB device state, or EUsbcDeviceStateUndefined if the UDC doesn't allow device state

   971 	tracking (PSL's DeviceStateChangeCaps() returns EFalse).

   972 */

   973 EXPORT_C TUsbcDeviceState DUsbClientController::GetDeviceStatus() const

   974 	{

   975 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::GetDeviceStatus()"));

   976 	return iDeviceState;

   977 	}

   978 

   979 

   980 /** Returns the state of an endpoint.

   981 

   982 	'Endpoint state' here refers to the state of the ENDPOINT_HALT feature of

   983 	an endpoint as described in chapter 9 of the USB specification.

   984 

   985 	@param aClientId A pointer to the LDD owning the interface which contains the endpoint to be queried.

   986 	@param aEndpointNum The number of the endpoint to be queried.

   987 

   988 	@return The current endpoint state, or EEndpointStateUnknown if the endpoint couldn't be found.

   989 */

   990 EXPORT_C TEndpointState DUsbClientController::GetEndpointStatus(const DBase* aClientId, TInt aEndpointNum) const

   991 	{

   992 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::GetEndpointStatus()"));

   993 	return EndpointStallStatus(aEndpointNum) ?

   994 		EEndpointStateStalled :

   995 		EEndpointStateNotStalled;

   996 	}

   997 

   998 

   999 /** Sets up a data read request for an endpoint.

  1000 

  1001 	@param aCallback A reference to a properly filled in data transfer request callback structure.

  1002 

  1003 	@return KErrNone if callback successfully registered or if this callback is already registered

  1004 	(but it won't be registered twice), KErrNotFound if the endpoint couldn't be found, KErrArgument if

  1005 	endpoint number invalid (PSL), KErrGeneral if something else goes wrong.

  1006 */

  1007 EXPORT_C TInt DUsbClientController::SetupReadBuffer(TUsbcRequestCallback& aCallback)

  1008 	{

  1009 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::SetupReadBuffer()"));

  1010 	const TInt ep = aCallback.iRealEpNum;

  1011 	__KTRACE_OPT(KUSB, Kern::Printf("  logical ep: #%d", aCallback.iEndpointNum));

  1012 	__KTRACE_OPT(KUSB, Kern::Printf("  real ep:    #%d", ep));

  1013 	TInt err = KErrGeneral;

  1014 	if (ep != 0)

  1015 		{

  1016 		if (iRequestCallbacks[ep])

  1017 			{

  1018 			__KTRACE_OPT(KPANIC, Kern::Printf("  Warning: RequestCallback already registered for that ep"));

  1019 			if (iRequestCallbacks[ep] == &aCallback)

  1020 				{

  1021 				__KTRACE_OPT(KPANIC, Kern::Printf("  (this same RequestCallback @ 0x%x)", &aCallback));

  1022 				}

  1023 			else

  1024 				{

  1025 				__KTRACE_OPT(KPANIC, Kern::Printf("  (a different RequestCallback @ 0x%x)", &aCallback));

  1026 				}

  1027 			return KErrNone;

  1028 			}

  1029 		// This may seem awkward:

  1030 		// First we add a callback, and then, in case of an error, we remove it again.

  1031 		// However this is necessary because the transfer request might complete (through

  1032 		// an ISR) _before_ the SetupEndpointRead function returns. Since we don't know the

  1033 		// outcome, we have to provide the callback before making the setup call.

  1034 		//

  1035 		__KTRACE_OPT(KUSB, Kern::Printf("  adding RequestCallback[%d] @ 0x%x", ep, &aCallback));

  1036 		iRequestCallbacks[ep] = &aCallback;

  1037 		if ((err = SetupEndpointRead(ep, aCallback)) != KErrNone)

  1038 			{

  1039 			__KTRACE_OPT(KPANIC, Kern::Printf("  removing RequestCallback @ 0x%x (due to error)",

  1040 											  &aCallback));

  1041 			iRequestCallbacks[ep] = NULL;

  1042 			}

  1043 		}

  1044 	else													// (ep == 0)

  1045 		{

  1046 		if (iEp0ReadRequestCallbacks.Elements() == KUsbcMaxListLength)

  1047 			{

  1048 			__KTRACE_OPT(KPANIC, Kern::Printf("  Error: Maximum list length reached: %d",

  1049 											  KUsbcMaxListLength));

  1050 			return KErrGeneral;

  1051 			}

  1052 		if (IsInTheRequestList(aCallback))

  1053 			{

  1054 			__KTRACE_OPT(KUSB, Kern::Printf("  RequestCallback @ 0x%x already registered", &aCallback));

  1055 			return KErrNone;

  1056 			}

  1057 		// Ep0 reads don't need to be prepared - there's always one pending

  1058 		__KTRACE_OPT(KUSB, Kern::Printf("  adding RequestCallback @ 0x%x (ep0)", &aCallback));

  1059 		TInt irq = NKern::DisableAllInterrupts();

  1060 		iEp0ReadRequestCallbacks.AddLast(aCallback);

  1061 		NKern::RestoreInterrupts(irq);

  1062 		err = KErrNone;

  1063 		if (iEp0_RxExtraData)

  1064 			{

  1065 			__KTRACE_OPT(KUSB, Kern::Printf("  iEp0_RxExtraData: trying again..."));

  1066 			const TBool rx_data = iEp0DataReceiving;

  1067 			const TInt irq = NKern::DisableAllInterrupts();

  1068 			err = ProcessEp0ReceiveDone(iEp0_RxExtraCount);

  1069 			NKern::RestoreInterrupts(irq);

  1070 			if (err == KErrNone)

  1071 				{

  1072 				iEp0_RxExtraData = EFalse;

  1073 				// Queue a new Ep0 read (because xxxProceed only re-enables the interrupt)

  1074 				SetupEndpointZeroRead();

  1075 				if (rx_data)

  1076 					{

  1077 					Ep0ReceiveProceed();

  1078 					}

  1079 				else

  1080 					{

  1081 					Ep0ReadSetupPktProceed();

  1082 					}

  1083 				__KTRACE_OPT(KUSB, Kern::Printf("  :-)"));

  1084 				}

  1085 			else

  1086 				{

  1087 				__KTRACE_OPT(KPANIC, Kern::Printf("  Error: :-("));

  1088 				err = KErrGeneral;

  1089 				}

  1090 			return err;

  1091 			}

  1092 		}

  1093 	return err;

  1094 	}

  1095 

  1096 

  1097 /** Sets up a data write request for an endpoint.

  1098 

  1099 	@param aCallback A reference to a properly filled in data transfer request callback structure.

  1100 

  1101 	@return KErrNone if callback successfully registered or if this callback is already registered

  1102 	(but it won't be registered twice), KErrNotFound if the endpoint couldn't be found, KErrArgument if

  1103 	endpoint number invalid (PSL), KErrGeneral if something else goes wrong.

  1104 */

  1105 EXPORT_C TInt DUsbClientController::SetupWriteBuffer(TUsbcRequestCallback& aCallback)

  1106 	{

  1107 	__KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::SetupWriteBuffer()"));

  1108 	TInt ep = aCallback.iRealEpNum;

  1109 	__KTRACE_OPT(KUSB, Kern::Printf("  logical ep: #%d", aCallback.iEndpointNum));

  1110 	__KTRACE_OPT(KUSB, Kern::Printf("  real ep:	   #%d", ep));

  1111 	if (iRequestCallbacks[ep])

  1112 		{

  1113 		__KTRACE_OPT(KPANIC, Kern::Printf("  Warning: RequestCallback already registered for that ep"));

  1114 		if (iRequestCallbacks[ep] == &aCallback)

  1115 			{

  1116 			__KTRACE_OPT(KPANIC, Kern::Printf("  (this same RequestCallback @ 0x%x)", &aCallback));

  1117 			return KErrNone;

  1118 			}

  1119 		else

  1120 			{

  1121 			__KTRACE_OPT(KPANIC, Kern::Printf("  (a different RequestCallback @ 0x%x - poss. error)",

  1122 											  &aCallback));

  1123 			return KErrGeneral;

  1124 			}

  1125 		}

  1126 	if (ep == 0)

  1127 		{

  1128 		if (iEp0_TxNonStdCount)

  1129 			{

  1130 			if (iEp0_TxNonStdCount > aCallback.iLength)

  1131 				{

  1132 				__KTRACE_OPT(KPANIC, Kern::Printf("  Warning: Ep0 is sending less data than requested"));

  1133 				if ((aCallback.iLength % iEp0MaxPacketSize == 0) && !aCallback.iZlpReqd)

  1134 					{