// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).+
−
// All rights reserved.+
−
// This component and the accompanying materials are made available+
−
// under the terms of "Eclipse Public License v1.0"+
−
// which accompanies this distribution, and is available+
−
// at the URL "http://www.eclipse.org/legal/epl-v10.html".+
−
//+
−
// Initial Contributors:+
−
// Nokia Corporation - initial contribution.+
−
//+
−
// Contributors:+
−
//+
−
// Description:+
−
//+
−
+
−
/**+
−
 @file+
−
 @internalComponent +
−
*/+
−
+
−
+
−
#include <obexusbtransportinfo.h>+
−
#include "usbconn.h"+
−
#include <obex/transport/obexconnector.h>+
−
#include "logger.h"+
−
#include "obexusbfaults.h"+
−
+
−
#ifdef __FLOG_ACTIVE+
−
_LIT8(KLogComponent, "USB");+
−
#endif+
−
+
−
#ifdef _DEBUG+
−
_LIT(KPanicCat, "ObexUsbHandler");+
−
#endif+
−
+
−
+
−
//+
−
+
−
/**+
−
CObexUsbActiveWriter factory function+
−
+
−
@param	aTransport	Reference to a CObexUsbTransportController object. Required for a call to the CObexUsbActiveReader+
−
@param	aOwner		Reference to a MObexTransportNotify object+
−
@param	aUsb		Reference to a RDevUsbcClient object+
−
@param	aInfo		Reference to a TObexConnectionInfo object+
−
@param  aPacketSize The size of packets used on the underlying link, dependent on High Speed mode.+
−
@return Ownership of a new CObexUsbActiveWriter.+
−
*/+
−
CObexUsbActiveWriter* CObexUsbActiveWriter::NewL(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb,+
−
										   TObexConnectionInfo& aInfo, TInt aPacketSize)+
−
	{+
−
	CObexUsbActiveWriter* self = new(ELeave) CObexUsbActiveWriter(aOwner, aUsb, aInfo, aPacketSize);+
−
	CleanupStack::PushL(self);+
−
	self->BaseConstructL();+
−
	CleanupStack::Pop(self);+
−
	return self;+
−
	}+
−
+
−
/**+
−
CObexUsbActiveWriter constructor+
−
+
−
@param	aTransport	Reference to a CObexUsbTransportController object. Required for a call to the CObexUsbActiveReader+
−
@param	aOwner		Reference to a MObexTransportNotify object+
−
@param	aUsb		Reference to a RDevUsbcClient object+
−
@param	aInfo		Reference to a TObexConnectionInfo object+
−
@param  aPacketSize The size of packets used on the underlying link, dependent on High Speed mode.+
−
*/+
−
CObexUsbActiveWriter::CObexUsbActiveWriter(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb,+
−
										   TObexConnectionInfo& aInfo, TInt aPacketSize)+
−
: CObexWriterBase(EPriorityHigh, aOwner, aInfo),+
−
 iUsb(aUsb), iPacketSize(aPacketSize)+
−
	{+
−
	}+
−
+
−
+
−
/**+
−
CObexUsbActiveWriter destructor.+
−
*/+
−
CObexUsbActiveWriter::~CObexUsbActiveWriter()+
−
	{+
−
	LOG_FUNC+
−
+
−
	Cancel();+
−
	}+
−
+
−
+
−
/**+
−
Start actual transfer.  May be called several times by CObexActiveRW::RunL.+
−
Queues a write on USB endpoint.+
−
*/+
−
void CObexUsbActiveWriter::DoTransfer()+
−
	{+
−
	LOG_FUNC+
−
	LOG1(_L("CObexUsbActiveWriter::DoTransfer [Length=%d]"),iLocation.Length());+
−
	+
−
	iLocation.SetMax();+
−
	iUsb.Write(iStatus, KTransmitEndpoint, iLocation, iLocation.Length(), ETrue);+
−
	SetActive();+
−
	}+
−
+
−
+
−
/**+
−
Cancels an outstanding write.+
−
*/+
−
void CObexUsbActiveWriter::DoCancel()+
−
	{+
−
	LOG_FUNC+
−
+
−
	//Only cancel the write if there's more than 1 packet left to write.+
−
	//This restriction is imposed to prevent the SUCCESS response being+
−
	//cancelled when an ObexServer is handling a disconnect and bringing +
−
	//the transport down.+
−
	if(Remaining() > iPacketSize)+
−
		{+
−
		iUsb.WriteCancel(KTransmitEndpoint);+
−
		}		+
−
	}+
−
		+
−
+
−
//+
−
+
−
/**+
−
CObexUsbActiveReader factory function+
−
+
−
@param	aOwner		Reference to a MObexTransportNotify object+
−
@param	aUsb		Reference to a RDevUsbcClient object+
−
@param	aInfo		Reference to a TObexConnectionInfo object+
−
@return Ownership of a new CObexUsbActiveWriter.+
−
*/+
−
CObexUsbActiveReader* CObexUsbActiveReader::NewL(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb,+
−
										   TObexConnectionInfo& aInfo)+
−
	{+
−
	CObexUsbActiveReader* self = new(ELeave) CObexUsbActiveReader(aOwner, aUsb, aInfo);+
−
	CleanupStack::PushL(self);+
−
	self->BaseConstructL();+
−
	CleanupStack::Pop(self);+
−
	return self;+
−
	}+
−
+
−
/**+
−
CObexUsbActiveReader constructor+
−
+
−
@param	aOwner		Reference to a MObexTransportNotify object+
−
@param	aUsb		Reference to a RDevUsbcClient object+
−
@param	aInfo		Reference to a TObexConnectionInfo object+
−
*/+
−
CObexUsbActiveReader::CObexUsbActiveReader(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb,+
−
										   TObexConnectionInfo& aInfo)+
−
: CObexReaderBase(EPriorityStandard, aOwner, aInfo), iUsb(aUsb)+
−
	{+
−
	}+
−
+
−
+
−
/**+
−
CObexUsbActiveReader destructor.+
−
*/+
−
CObexUsbActiveReader::~CObexUsbActiveReader()+
−
	{+
−
	LOG_FUNC+
−
+
−
	Cancel();+
−
	}+
−
+
−
+
−
/**+
−
Start actual transfer.  May be called several times by CObexActiveRW::RunL.+
−
Queues a read on USB endpoint.+
−
*/+
−
void CObexUsbActiveReader::DoTransfer()+
−
	{+
−
	LOG_FUNC+
−
	LOG1(_L("CObexUsbActiveReader::DoTransfer [maxLength=%d]"),iLocation.MaxLength());+
−
+
−
	iUsb.ReadUntilShort(iStatus, KReceiveEndpoint, iLocation);+
−
	SetActive();+
−
	}+
−
+
−
+
−
/**+
−
Cancels an outstanding read,+
−
 */+
−
void CObexUsbActiveReader::DoCancel()+
−
	{+
−
	FLOG(_L("CObexUsbActiveReader::DoCancel"));+
−
+
−
	iUsb.ReadCancel(KReceiveEndpoint);+
−
	}+
−
+
−
+
−
/**+
−
Return the maximum packet size+
−
@return TInt the maximum packet size for this transport+
−
*/+
−
TInt CObexUsbActiveReader::GetMaxPacketSize()+
−
	{+
−
	LOG_FUNC+
−
+
−
	return GetObexPacketDataLimit();+
−
	}+
−
+
−
+
−
/**+
−
Returns a initial packet size when the packet size of iPacket is not know.  This is used+
−
when determining the remaining bytes to be read.  +
−
@return TInt the initial packet size+
−
*/+
−
TInt CObexUsbActiveReader::GetInitialPacketSize ()+
−
	{+
−
	LOG_FUNC+
−
	+
−
	return GetObexPacketBufferSize();+
−
	}+
−
//+
−
+
−
/**+
−
CObexUsbConnector constructor.+
−
*/+
−
CObexUsbConnector::CObexUsbConnector(MObexTransportNotify& aObserver, TObexUsbTransportInfo& aUsbTransportInfo)+
−
 :	CObexConnector(aObserver), +
−
	iObexTransportInfo(aUsbTransportInfo), +
−
	iMode(EDefaultClient)+
−
	{+
−
	LOG_FUNC+
−
	// Note iObexTransportInfo reference is only kept so that it can be used in the ConstructL+
−
	// It may not be safe to use this variables outside of the construction phases+
−
	}+
−
+
−
+
−
/*+
−
Returns an instance of CObexUsbConnector+
−
+
−
@param	aController  	Reference to a MObexTransportNotify object (the CObexUsbTransportController that owns this)+
−
@param	aTransportInfo 	Reference to a TObexUsbTransportInfo object containing the transport information+
−
+
−
@return	A pointer to a CObexUsbConnector object+
−
*/+
−
CObexUsbConnector* CObexUsbConnector::NewL(MObexTransportNotify& aController, TObexUsbTransportInfo& aTransportInfo)+
−
	{+
−
	CObexUsbConnector* self = new(ELeave) CObexUsbConnector(aController, aTransportInfo);+
−
	CleanupStack::PushL(self);+
−
	self->ConstructL();+
−
	CleanupStack::Pop(self);+
−
	return(self);+
−
	}+
−
+
−
+
−
/**+
−
Second phase construction.+
−
*/+
−
void CObexUsbConnector::ConstructL()+
−
	{+
−
	LOG_FUNC+
−
+
−
	OpenUsbL(0);+
−
+
−
	FLOG(_L("USB opened"));+
−
+
−
	iHandler  = CObexUsbHandler::NewL(iObexTransportInfo, *this, iUsb);+
−
	iCallback = new(ELeave) CAsyncCallBack(EPriorityHigh);+
−
	iStaller = CObexUsbStaller::NewL(iUsb, *this);+
−
	iHandler->Start();+
−
+
−
	BaseConstructL();+
−
	}+
−
+
−
+
−
/**+
−
CObexUsbConnector destructor. Releases endpoint and closes USB object if we have an open connection.+
−
*/+
−
CObexUsbConnector::~CObexUsbConnector()+
−
	{+
−
	LOG_FUNC+
−
+
−
	delete iCallback;+
−
	delete iHandler;+
−
	delete iStaller;+
−
	+
−
	if (iUsb.Handle())+
−
		{	+
−
		iUsb.Close();+
−
		}+
−
	}+
−
+
−
+
−
/**+
−
Attempt to open a client-type connection.+
−
This will succeed if the USB host has already opened a connection to us+
−
*/+
−
void CObexUsbConnector::ConnectL()+
−
	{+
−
	LOG_FUNC+
−
+
−
	if (iMode == EServer)+
−
		{+
−
		// Already performed a server-type connect, so can't act as a+
−
		// client as well.+
−
		FLOG(_L(" -- In server mode, give up"));+
−
		LEAVEIFERRORL(KErrNotSupported);		+
−
		}+
−
		+
−
		+
−
	FLOG(_L(" -- Not in server mode"));+
−
+
−
	iMode = EClient;+
−
	if (iTransportLinkAvailable)+
−
		{+
−
		FLOG(_L(" -- Link available, set a callback"));+
−
+
−
		TCallBack callback(LinkUp, this);+
−
		iCallback->Set(callback);+
−
		iCallback->CallBack();+
−
		iConnectRequested = ETrue;+
−
		}+
−
	else+
−
		{+
−
		FLOG(_L(" -- No link available, set a callback"));+
−
+
−
		TCallBack callback(NoDevice, this);+
−
		iCallback->Set(callback);+
−
		iCallback->CallBack();+
−
		}+
−
	}+
−
+
−
+
−
/*+
−
@param	aConn	A pointer to a connector object. Will be cast to CObexUsbConnector+
−
+
−
@return	KErrNone+
−
*/+
−
TInt CObexUsbConnector::LinkUp(TAny* aConn)+
−
	{+
−
	FLOG(_L("CObexUsbConnector::LinkUp"));+
−
+
−
	reinterpret_cast<CObexUsbConnector*>(aConn)->SignalUp();+
−
	return KErrNone;+
−
	}+
−
+
−
+
−
/*+
−
@param	aConn	A pointer to a connector object. Will be cast to CObexUsbConnector+
−
+
−
@return	KErrNone+
−
*/+
−
TInt CObexUsbConnector::NoDevice(TAny* aConn)+
−
	{+
−
	FLOG(_L("CObexUsbConnector::NoDevice"));+
−
+
−
	reinterpret_cast<CObexUsbConnector*>(aConn)->SignalDown(KErrIrObexClientPeerDoesNotHaveObex);+
−
	return KErrNone;+
−
	}+
−
+
−
+
−
/**+
−
Cancel an active connection attempt.  This is unlikely to succeed, as a client+
−
connection over USB will complete almost immediately.+
−
*/+
−
void CObexUsbConnector::CancelConnect()+
−
	{+
−
	LOG_FUNC+
−
+
−
	if (iMode == EClient)+
−
		{+
−
		iCallback->Cancel();+
−
		}+
−
	+
−
	iConnectRequested = EFalse;+
−
	}+
−
+
−
+
−
/**+
−
Start listening for a connection to us.+
−
*/+
−
void CObexUsbConnector::AcceptL()+
−
	{+
−
	LOG_FUNC+
−
+
−
	if (iMode == EClient)+
−
		{+
−
		// Already carried out a client side connection.  Therefore we+
−
		// can't be a server as well.+
−
		FLOG(_L(" -- In client mode, give up"));+
−
+
−
		LEAVEIFERRORL(KErrNotSupported);		+
−
		}+
−
	+
−
	FLOG(_L(" -- Not in client mode"));+
−
+
−
	iMode = EServer;+
−
	if (iTransportLinkAvailable)+
−
		{+
−
		FLOG(_L(" -- Transport link currently available, set a callback"));+
−
+
−
		TCallBack callback(LinkUp, this);+
−
		iCallback->Set(callback);+
−
		iCallback->CallBack();+
−
		}+
−
	else+
−
		{+
−
		FLOG(_L(" -- No link available, wait for one"));+
−
+
−
		iWaitingForLink = ETrue;+
−
		}+
−
	}+
−
+
−
/**+
−
Stop listening for connections.+
−
*/+
−
void CObexUsbConnector::CancelAccept()+
−
	{+
−
	LOG_FUNC+
−
+
−
	if (iMode == EServer)+
−
		{+
−
		iWaitingForLink = EFalse;+
−
		iCallback->Cancel();+
−
		}+
−
	}+
−
+
−
+
−
/**+
−
Called to indicate transport layer has come up.+
−
*/+
−
void CObexUsbConnector::TransportUp()+
−
	{+
−
	LOG_FUNC+
−
	+
−
	SetTransportPacketSize();+
−
+
−
	iTransportLinkAvailable = ETrue;+
−
	+
−
	if ((iMode == EServer) && (iWaitingForLink))+
−
		{+
−
		FLOG(_L(" -- Signalling link available"));+
−
+
−
		iWaitingForLink = EFalse;+
−
		SignalUp();+
−
		}+
−
	}+
−
+
−
/**+
−
Called to indicate transport layer has gone down.+
−
+
−
@param	aErr 	Any error code associated with disconnection. Defaults to KErrDisconnected.+
−
*/+
−
void CObexUsbConnector::TransportDown(TInt aErr)+
−
	{+
−
	LOG_FUNC+
−
	+
−
	ResetTransportPacketSize();+
−
	+
−
	iStaller->Cancel();+
−
+
−
	iTransportLinkAvailable = EFalse;+
−
		+
−
	if (iMode == EServer)+
−
		{+
−
		FLOG(_L(" -- In server mode, signal link down"));+
−
+
−
		SignalDown(aErr);+
−
		}+
−
	else+
−
		{+
−
		FLOG(_L(" -- In client mode"));+
−
+
−
		// Client or default client state+
−
		if (iConnectRequested)+
−
			{+
−
			FLOG(_L(" -- Outstanding client connection. Signal link down"));+
−
+
−
			iConnectRequested = EFalse;+
−
			SignalDown(aErr);+
−
			}+
−
		}+
−
	}+
−
+
−
/**+
−
Signals to the transport controller that the transport is up+
−
*/+
−
void CObexUsbConnector::SignalUp()+
−
	{+
−
	LOG_FUNC+
−
+
−
	// Indicate transport now up+
−
	TObexConnectionInfo sockinfo;+
−
	sockinfo.iMaxRecvSize = 0;	// set these to zero as we can't find them out+
−
	sockinfo.iMaxSendSize = 0;	// and they are not used+
−
	sockinfo.iSocketType = TObexConnectionInfo::EUsbStream;+
−
	Observer().TransportUp(sockinfo);+
−
	}+
−
+
−
+
−
/**+
−
Signals (with an error code) to the transport controller that the transport has gone down +
−
*/+
−
void CObexUsbConnector::SignalDown(TInt aErr)+
−
	{+
−
	FLOG(_L("CObexUsbConnector::SignalDown"));+
−
+
−
	Observer().Error(aErr);+
−
	}+
−
+
−
+
−
/**+
−
The Obex server running over USB is not able to bring the transport+
−
down itself. It will only delete the transport object when an error+
−
has occurred (such as the link being brought down) and hence the+
−
transport is no longer valid.+
−
+
−
@return	ETrue+
−
*/+
−
TBool CObexUsbConnector::BringTransportDown()+
−
{+
−
	// This cancel function needs to be called here because it+
−
	// doesn't get called anywhere else. Bluetooth and IrDA rely+
−
	// on the socket shutdown to cancel the accept.+
−
	CancelAccept();+
−
	return ETrue;+
−
}+
−
+
−
+
−
/**+
−
Return the transport layer object for use by USB transport objects+
−
+
−
@return Pointer to the USB transport layer object+
−
*/+
−
RDevUsbcClient* CObexUsbConnector::TransportObject()+
−
	{+
−
	return &iUsb;+
−
	}+
−
+
−
+
−
/**+
−
Sets a bus stall condition on the IN endpoint.  This will cause the USB+
−
host to initiate a CLEAR_FEATURE sequence, which notifies the server that the+
−
Obex link has been reset (equivalent to dropping the Obex level connection)+
−
*/+
−
void CObexUsbConnector::SignalTransportError()+
−
	{+
−
	LOG_FUNC+
−
	+
−
	iStaller->Start();+
−
	iTransportLinkAvailable = EFalse;+
−
	iConnectRequested = EFalse;+
−
	}+
−
+
−
+
−
/**+
−
Stall cleared => transport available.+
−
This upcall has been separated from the TransportUp upcall for two+
−
reasons---it's called from a different class and it happens when an+
−
error condition has been cleared.  Currently it has no special+
−
meaning, but this could change in future.+
−
*/+
−
void CObexUsbConnector::StallCleared()+
−
	{+
−
	LOG_FUNC+
−
	+
−
	TransportUp();+
−
	}+
−
+
−
+
−
/**+
−
Opens USB and prepares it for use.+
−
+
−
@param	aUnit	According to the RDevUsbcClient documentation, this should be 0. +
−
*/+
−
void CObexUsbConnector::OpenUsbL(TInt aUnit)+
−
	{+
−
	LOG1(_L("CObexUsbConnector::OpenUsbL called for unit=%d"), aUnit);+
−
	+
−
	// Load ldd+
−
	TInt err = User::LoadLogicalDevice(KUsbLddName);+
−
+
−
	if (err != KErrNone && err != KErrAlreadyExists)+
−
		{+
−
		LEAVEIFERRORL(err);+
−
		}+
−
+
−
	// Open the requested unit and initialise local state+
−
	LEAVEIFERRORL(iUsb.Open(aUnit));+
−
	}+
−
+
−
+
−
void CObexUsbConnector::ResetTransportPacketSize()+
−
	{+
−
	iPacketSize = 0;+
−
	}+
−
+
−
+
−
void CObexUsbConnector::SetTransportPacketSize()+
−
	{+
−
	if (iUsb.CurrentlyUsingHighSpeed())+
−
		{+
−
		iPacketSize = KMaxPacketTypeBulkHS;+
−
		}+
−
	else+
−
		{+
−
		iPacketSize = KMaxPacketTypeBulkFS;+
−
		}+
−
	}+
−
+
−
+
−
TInt CObexUsbConnector::GetTransportPacketSize()+
−
	{+
−
	return iPacketSize;+
−
	}+
−
+
−
+
−
//+
−
+
−
/**+
−
Constructs a CObexUsbHandler object+
−
+
−
@param	aUsbTransportInfo	Reference to a TObexTransportInfo object. Will be cast to TObexUsbTransportInfo.+
−
@param	aOwner				Reference to a MObexUsbConnector that owns this handler+
−
@param	aUsb				Reference to a RDevUsbcClient object.+
−
+
−
@return	A new CObexUsbHandler object+
−
*/+
−
CObexUsbHandler* CObexUsbHandler::NewL(TObexUsbTransportInfo& aUsbTransportInfo,+
−
									   MObexUsbConnector& aOwner,+
−
									   RDevUsbcClient& aUsb)+
−
	{+
−
	FLOG(_L("CObexUsbHandler::NewL"));+
−
	+
−
	CObexUsbHandler* self = new (ELeave) CObexUsbHandler(aUsbTransportInfo, aOwner, aUsb);+
−
	CleanupStack::PushL(self);+
−
	self->ConstructL();+
−
	CleanupStack::Pop(self);+
−
	return self;+
−
	}+
−
+
−
+
−
/**+
−
CObexUsbHandler constructor.+
−
+
−
Note that the iObexTransportInfo may not be valid outside of the construction phases+
−
The constructor copies out most of the information it needs into member variables+
−
apart from the interface string descriptor, which is used from RegInterfacesL+
−
+
−
@param	aUsbTransportInfo	Reference to a TObexTransportInfo object. Will be cast to TObexUsbTransportInfo.+
−
@param	aOwner				Reference to a MObexUsbConnector that owns this handler+
−
@param	aUsb				Reference to a RDevUsbcClient object.+
−
*/+
−
CObexUsbHandler::CObexUsbHandler(TObexUsbTransportInfo& aUsbTransportInfo,+
−
								 MObexUsbConnector& aOwner,+
−
								 RDevUsbcClient& aUsb)+
−
 : CActive(EPriorityStandard), iObexTransportInfo(aUsbTransportInfo),+
−
   iOwner(aOwner), iUsb(aUsb)+
−
	{+
−
	LOG_FUNC+
−
	+
−
	CActiveScheduler::Add(this);+
−
+
−
	// Set interface performance configuration parameters+
−
	if (aUsbTransportInfo.iTransportName == KObexUsbProtocol)+
−
		// Default values if transport is normal USB - no extra bandwidth, no DMA+
−
		{+
−
		FLOG(_L("CObexUsbHandler - Using default USB protocol info"));+
−
		iBandwidthPriority = EUsbcBandwidthOUTDefault | EUsbcBandwidthINDefault;+
−
		iRequestDmaOnOutEndpoint = EFalse;+
−
		iRequestDmaOnInEndpoint = EFalse;+
−
		}+
−
	else if (aUsbTransportInfo.iTransportName == KObexUsbProtocolV2)+
−
		// If transport is extended USB take values from the protocol info+
−
		{+
−
		FLOG(_L("CObexUsbHandler - Using USB protocol extended info"));+
−
		TObexUsbV2TransportInfo& infoV2 = static_cast<TObexUsbV2TransportInfo&>(aUsbTransportInfo);+
−
		iBandwidthPriority       = infoV2.iBandwidthPriority;+
−
		iRequestDmaOnOutEndpoint = infoV2.iDmaOnOutEndpoint;+
−
		iRequestDmaOnInEndpoint  = infoV2.iDmaOnInEndpoint;+
−
		}+
−
	else+
−
		{+
−
		//aUsbTransportInfo.iTransportName is used to load the correct plug-in, so if this code+
−
		//is being executed it must have contained one of the options above. Else something+
−
		//has gone badly wrong.+
−
		__ASSERT_DEBUG(false, PANIC(KPanicCat, EUnknownUsbTransport));+
−
		}+
−
+
−
	LOG3(_L("CObexUsbHandler - iBandwidthPriority 0x%X, iDmaOnOutEndpoint, %d iDmaOnInEndpoint %d"),+
−
						iBandwidthPriority, iRequestDmaOnOutEndpoint, iRequestDmaOnInEndpoint);+
−
	}+
−
+
−
+
−
/**+
−
Second phase construction.+
−
*/+
−
void CObexUsbHandler::ConstructL()+
−
	{+
−
+
−
	// Check bandwidth priority to make sure it makes sense+
−
	// Reasoning is that the bitwise OR of the maximum values of IN and OUT priorities+
−
	// covers all the bits that can be set in iBandwidthPriority so, using this as a mask,+
−
	// anything set outside of this indicates that iBandwidthPriority is corrupt+
−
	if ( ( iBandwidthPriority & ~( EUsbcBandwidthOUTMaximum | EUsbcBandwidthINMaximum ) ) != 0 )+
−
		{+
−
		LEAVEIFERRORL(KErrArgument);+
−
		}+
−
+
−
	FLOG(_L("About to open USB comms interface connection"));+
−
+
−
	LEAVEIFERRORL(iUsbComms.Open(0));+
−
+
−
	FLOG(_L("Registering interfaces"));+
−
+
−
	RegInterfacesL();+
−
	}+
−
+
−
+
−
/**+
−
CObexUsbHandler destructor.+
−
*/+
−
CObexUsbHandler::~CObexUsbHandler()+
−
	{+
−
	LOG_FUNC+
−
	Cancel();+
−
+
−
	// Must release interfaces from highest alternate setting downwards+
−
	if (iUsb.Handle())+
−
		{+
−
#ifndef NO_ALTERNATE_USB_INTERFACE_SUPPORT+
−
		iUsb.ReleaseInterface(1 /*alternate setting*/);+
−
#endif+
−
		iUsb.ReleaseInterface(0 /*alternate setting*/);+
−
		}+
−
+
−
	if (iUsbComms.Handle())+
−
		{	+
−
		iUsbComms.ReleaseInterface(0 /*alternate setting*/);+
−
		}+
−
+
−
	iUsbComms.Close();+
−
	}+
−
+
−
+
−
/**+
−
Standard active object error function.+
−
+
−
@return	KErrNone because currently nothing should cause this to be called.+
−
*/+
−
TInt CObexUsbHandler::RunError(TInt /*aError*/)+
−
	{+
−
	return KErrNone;+
−
	}+
−
+
−
+
−
/**+
−
This function will be called upon a change in the state of the device+
−
(as set up in AcceptL).+
−
*/+
−
void CObexUsbHandler::RunL()+
−
	{+
−
	LOG1(_L("CObexUsbHandler::RunL called state=0x%X"), iUsbState);+
−
	+
−
	if (iStatus != KErrNone)+
−
		{+
−
		LOG1(_L("CObexUsbHandler::RunL() - Error = %d"),iStatus.Int());+
−
+
−
		iTransportUp = EFalse;+
−
		iOwner.TransportDown(iStatus.Int());+
−
		return;+
−
		}+
−
+
−
	// Check whether the alternate setting to use or the device state has changed.+
−
	// We have to check the device state to handle the unplugging of the cable. We can't+
−
	// rely on the always-outstanding read to complete with an error, because the driver+
−
	// doesn't have a well-defined error code for this.+
−
+
−
	if (iUsbState & KUsbAlternateSetting)+
−
		{+
−
		iUsbState &= ~KUsbAlternateSetting;+
−
+
−
		LOG1(_L("switched to alternate setting %d"), iUsbState);+
−
+
−
		if (iUsbState == KObexAlt0)+
−
			{+
−
			// alternate setting 0 - function inactive+
−
			if (iTransportUp)+
−
				{+
−
				FLOG(_L("CObexUsbHandler::RunL - transport layer going down..."));+
−
+
−
				iTransportUp = EFalse;+
−
				iOwner.TransportDown();+
−
				}+
−
			}+
−
		else if (iUsbState == KObexAlt1)+
−
			{+
−
			// alternate setting 1 - function active+
−
			if (!iTransportUp)+
−
				{+
−
				FLOG(_L("CObexUsbHandler::RunL - transport layer coming up..."));+
−
+
−
				// Now the transport is selected, DMA can be allocated to the endpoints, if required+
−
				AllocateDma();+
−
+
−
				iTransportUp = ETrue;+
−
+
−
				iOwner.TransportUp();+
−
				}+
−
			}+
−
		else+
−
			{+
−
			FLOG(_L("WARNING: unknown setting!"));+
−
			}+
−
		}+
−
	else+
−
		{+
−
		TUsbcDeviceState deviceState = static_cast<TUsbcDeviceState>(iUsbState);+
−
+
−
		switch(deviceState)+
−
			{+
−
			case EUsbcDeviceStateUndefined:+
−
			case EUsbcDeviceStateAttached:+
−
			case EUsbcDeviceStatePowered:+
−
			case EUsbcDeviceStateDefault:+
−
			case EUsbcDeviceStateAddress:+
−
#ifdef ERRONEOUS_SUSPEND_INDICATIONS+
−
			// On Lubbock, we sometimes get "suspended" when the cable is unplugged.+
−
			case EUsbcDeviceStateSuspended:+
−
#endif // ERRONEOUS_SUSPEND_INDICATIONS+
−
				if (iTransportUp)+
−
					{+
−
					FLOG(_L("CObexUsbHandler::RunL - transport layer going down..."));+
−
+
−
					iTransportUp = EFalse;+
−
					iOwner.TransportDown();+
−
					}+
−
				break;+
−
+
−
#ifndef ERRONEOUS_SUSPEND_INDICATIONS+
−
			case EUsbcDeviceStateSuspended:+
−
				break;+
−
#endif // !ERRONEOUS_SUSPEND_INDICATIONS+
−
+
−
			case EUsbcDeviceStateConfigured:+
−
				// Normally, we don't do anything here, because the transport only goes up when+
−
				// we actually receive the alternate interface change.+
−
#ifdef NO_ALTERNATE_USB_INTERFACE_SUPPORT+
−
				if (!iTransportUp)+
−
					{+
−
					FLOG(_L("Device now configured: transport layer coming up..."));+
−
+
−
					iTransportUp = ETrue;+
−
+
−
					// DMA can be allocated to the endpoints, if required+
−
					// This has to be done here for no alternate interface devices+
−
					// as they will not receive interface change notification+
−
					AllocateDma();+
−
+
−
					iOwner.TransportUp();+
−
					}+
−
#endif // NO_ALTERNATE_USB_INTERFACE_SUPPORT+
−
				break;+
−
+
−
			default:+
−
				__ASSERT_DEBUG(false, PANIC(KPanicCat, EUnknownUsbState));+
−
				break;+
−
			}+
−
		}+
−
+
−
	// Await further notification of a state change. We may have called Error(), which+
−
	// would already have set this notification request.+
−
	if (!IsActive())+
−
		{+
−
		iUsb.AlternateDeviceStatusNotify(iStatus, iUsbState);+
−
		SetActive();+
−
		}+
−
+
−
	FLOG(_L("CObexUsbHandler::RunL finished"));+
−
	}+
−
+
−
+
−
/**+
−
Standard active object cancellation function.+
−
*/+
−
void CObexUsbHandler::DoCancel()+
−
	{+
−
	LOG_FUNC+
−
+
−
	iUsb.AlternateDeviceStatusNotifyCancel();+
−
	}+
−
+
−
+
−
/**+
−
Registers the required comms and data interfaces.+
−
*/+
−
void CObexUsbHandler::RegInterfacesL()+
−
	{+
−
	LOG_FUNC+
−
+
−
	// Setup a CDC Communication Class interface+
−
	TUsbcInterfaceInfoBuf ifc;+
−
+
−
	// Extract the interface string from the transport info structure we were+
−
	// passed on construction. This isn't const because the SetInterface API+
−
	// requires it not to be.+
−
	// This is the only point where iObexTransportInfo is used directly+
−
	// Do not use iObexTransportInfo outside of construction phases+
−
	TPtrC string(iObexTransportInfo.iInterfaceStringDescriptor);+
−
+
−
	LOG1(_L("Using interface string \"%S\""), &string);+
−
		+
−
	ifc().iString = &string;+
−
	ifc().iClass.iClassNum = KObexClassNumber;		+
−
	ifc().iClass.iSubClassNum = KObexSubClassNumber;+
−
	ifc().iClass.iProtocolNum = KObexProtocolNumber;+
−
	ifc().iTotalEndpointsUsed = 0;+
−
	+
−
	// Indicate that this interface does not expect any control transfers +
−
	// from EP0.+
−
	ifc().iFeatureWord |= KUsbcInterfaceInfo_NoEp0RequestsPlease;+
−
	+
−
	FLOG(_L("CObexUsbListeningConnector::RegInterfacesL - setting comms interface")); +
−
	+
−
	TInt err = iUsbComms.SetInterface(0, ifc);+
−
+
−
	if (err != KErrNone) +
−
		{ +
−
		LOG1(_L("SetInterface failed with error %d"), err);+
−
		LEAVEIFERRORL(err);+
−
		}+
−
+
−
	// Get the interface number for later +
−
	TInt intDescSize;+
−
	err = iUsbComms.GetInterfaceDescriptorSize(0,intDescSize);	+
−
	if(err != KErrNone)+
−
		{+
−
		LOG1(_L("Failed to get interface descriptor size. Err = %d"),err);+
−
		intDescSize = KObexDefaultInterfaceDescriptorLength; //Default is 100+
−
		}+
−
	HBufC8* interfaceDescriptor;+
−
	interfaceDescriptor = HBufC8::NewLC(intDescSize);+
−
	TPtr8 pIntDesc = interfaceDescriptor->Des();+
−
	iUsbComms.GetInterfaceDescriptor(0, pIntDesc);+
−
	TUint8 obexIntNo = interfaceDescriptor->Ptr()[2];+
−
	CleanupStack::PopAndDestroy();+
−
+
−
	TBuf8<KObexInterfaceDescriptorBlockLength> desc;+
−
+
−
	// Comms Class Header Functional Descriptor+
−
+
−
	desc.Append(KObexFunctionalDescriptorLength);+
−
	desc.Append(KUsbDescType_CS_Interface);+
−
	desc.Append(KHeaderFunctionalDescriptor);+
−
	desc.Append(KCdcVersionNumber[0]);+
−
	desc.Append(KCdcVersionNumber[1]);+
−
+
−
	// Obex Functional Descriptor+
−
+
−
	desc.Append(KObexFunctionalDescriptorLength);+
−
	desc.Append(KUsbDescType_CS_Interface);+
−
	desc.Append(KObexFunctionalDescriptor);+
−
	desc.Append(KWmcdcVersionNumber[0]);+
−
	desc.Append(KWmcdcVersionNumber[1]);+
−
+
−
	// Union Functional Descriptor+
−
	+
−
	desc.Append(KObexFunctionalDescriptorLength);+
−
	desc.Append(KUsbDescType_CS_Interface); +
−
	desc.Append(KUnionFunctionalDescriptor);+
−
	desc.Append(obexIntNo); +
−
	TInt dataInt = obexIntNo + 1;+
−
	desc.Append(static_cast<TUint8>(dataInt));		+
−
+
−
	err = iUsbComms.SetCSInterfaceDescriptorBlock(0, desc);+
−
	if (err != KErrNone)+
−
		{+
−
		LOG1(_L("SetCSInterfaceDescriptorBlock failed with error %d"), err);+
−
		LEAVEIFERRORL(err);+
−
		}+
−
+
−
	// Setup CDC Data Class interfaces+
−
+
−
	// Only set the "function inactive" interface (alternate setting 0)+
−
	// if the device can support alternate interfaces+
−
#ifndef NO_ALTERNATE_USB_INTERFACE_SUPPORT+
−
	TUsbcInterfaceInfoBuf dataifc;+
−
+
−
	dataifc().iString = NULL;+
−
	dataifc().iClass.iClassNum = KObexDataClass;		+
−
	dataifc().iClass.iSubClassNum = KObexDataSubClass;+
−
	dataifc().iClass.iProtocolNum = 0;+
−
	dataifc().iTotalEndpointsUsed = 0;+
−
+
−
	// Indicate that this interface does not expect any control transfers +
−
	// from EP0.+
−
	dataifc().iFeatureWord |= KUsbcInterfaceInfo_NoEp0RequestsPlease;+
−
+
−
	FLOG(_L("Setting data class interface (alt setting 0")); +
−
	+
−
	err = iUsb.SetInterface(0 /*alternate setting*/, dataifc, iBandwidthPriority);+
−
	if (err != KErrNone) +
−
		{+
−
		LOG1(_L("Cannot set data interface (alternate setting 0): error %d"), err);+
−
		LEAVEIFERRORL(err);+
−
		}+
−
+
−
	// If anything below this point leaves, make sure this alternate setting+
−
	// gets released.+
−
	CleanupStack::PushL(TCleanupItem(CleanupReleaseInterface0, &iUsb));+
−
#endif // NO_ALTERNATE_USB_INTERFACE_SUPPORT+
−
+
−
	// Check the device has enough endpoints for the "function active" data interface+
−
	TUsbDeviceCaps dCaps;+
−
	LEAVEIFERRORL(iUsb.DeviceCaps(dCaps));+
−
	+
−
	TInt n = dCaps().iTotalEndpoints;+
−
	if (n < KObexMinNumEndpoints) +
−
		{+
−
		LEAVEIFERRORL(KErrOverflow);+
−
		}+
−
	+
−
	// Use the hardware's HS capability to determine maximum bulk transfer packet size+
−
	TInt maxPacketSize = (dCaps().iHighSpeed) ? KMaxPacketTypeBulkHS : KMaxPacketTypeBulkFS;+
−
	+
−
		+
−
	// Get information on the available endpoints from the driver+
−
	TUsbcEndpointData data[KUsbcMaxEndpoints];+
−
	TPtr8 dataptr(REINTERPRET_CAST(TUint8*, data), sizeof(data), sizeof(data));+
−
	LEAVEIFERRORL(iUsb.EndpointCaps(dataptr));+
−
+
−
	// Check to see if there are suitably capable IN and OUT endpoints available+
−
	// and fill dataifc2 structure accordingly.+
−
	//+
−
	// NOTE: The order the iEndpointData array is filled matches the order used for the+
−
	// virtual endpoint numbers KTransmitEndpoint and KReceiveEndpoint - so change with caution!+
−
	//+
−
	// The virtual endpoint numbers are 1-based, whereas the iEndpointData array is 0 based+
−
	// hence the subtraction in the array indices+
−
	//+
−
	// NOTE: IN and OUT refer to the host so in this case:+
−
	//			IN  => device to PC = KTransmitEndpoint+
−
	//			OUT => PC to device = KReceiveEndpoint+
−
	TUsbcInterfaceInfoBuf dataifc2;+
−
	TBool foundIn = EFalse;+
−
	TBool foundOut = EFalse;+
−
	for (TInt i = 0; !(foundIn && foundOut) && i < n; i++)+
−
		{+
−
		const TUsbcEndpointCaps* caps = &data[i].iCaps;+
−
		if (data[i].iInUse)+
−
			{+
−
			continue;+
−
			}+
−
			+
−
		const TUint KBulkInFlags = KUsbEpTypeBulk | KUsbEpDirIn;+
−
		const TUint KBulkOutFlags = KUsbEpTypeBulk | KUsbEpDirOut;+
−
+
−
		if (!foundIn && (caps->iTypesAndDir & KBulkInFlags) == KBulkInFlags)+
−
			{+
−
			dataifc2().iEndpointData[KTransmitEndpoint - 1].iType  = KUsbEpTypeBulk;+
−
			dataifc2().iEndpointData[KTransmitEndpoint - 1].iDir   = KUsbEpDirIn;	+
−
			TInt maxSize = caps->MaxPacketSize();+
−
			if (maxSize > maxPacketSize)+
−
				{+
−
				maxSize = maxPacketSize;+
−
				}+
−
			dataifc2().iEndpointData[KTransmitEndpoint - 1].iSize  = maxSize;+
−
			+
−
			// Allocate dma if requested and the device support resource allocation scheme version 2+
−
			// for resource allocation scheme version1, refer to AllocateDma()+
−
			if (iRequestDmaOnInEndpoint && +
−
				((dCaps().iFeatureWord1 & KUsbDevCapsFeatureWord1_EndpointResourceAllocV2) != 0))+
−
				{+
−
				dataifc2().iEndpointData[KTransmitEndpoint - 1].iFeatureWord1 |= KUsbcEndpointInfoFeatureWord1_DMA;+
−
				}+
−
+
−
			foundIn = ETrue;+
−
			}+
−
		else if (!foundOut && (caps->iTypesAndDir & KBulkOutFlags) == KBulkOutFlags)+
−
			{+
−
			dataifc2().iEndpointData[KReceiveEndpoint - 1].iType = KUsbEpTypeBulk;+
−
			dataifc2().iEndpointData[KReceiveEndpoint - 1].iDir = KUsbEpDirOut;+
−
			TInt maxSize = caps->MaxPacketSize();+
−
			if (maxSize > maxPacketSize)+
−
				{+
−
				maxSize = maxPacketSize;+
−
				}+
−
			dataifc2().iEndpointData[KReceiveEndpoint - 1].iSize  = maxSize;+
−
			+
−
			//Allocate dma here if requested and the device support resource allocation scheme version 2+
−
			// for resource allocation scheme version1, refer to AllocateDma()+
−
			if (iRequestDmaOnOutEndpoint && +
−
				((dCaps().iFeatureWord1 & KUsbDevCapsFeatureWord1_EndpointResourceAllocV2) != 0))+
−
				{+
−
				dataifc2().iEndpointData[KReceiveEndpoint - 1].iFeatureWord1 |= KUsbcEndpointInfoFeatureWord1_DMA;+
−
				}+
−
			+
−
			foundOut = ETrue;+
−
			}+
−
		}+
−
		+
−
	if (!(foundIn && foundOut)) +
−
		{+
−
		LEAVEIFERRORL(KErrHardwareNotAvailable);+
−
		}+
−
	+
−
	// Set the active interface.+
−
	dataifc2().iString = NULL;+
−
	dataifc2().iClass.iClassNum = KObexDataClass;		+
−
	dataifc2().iClass.iSubClassNum = KObexDataSubClass;+
−
	dataifc2().iClass.iProtocolNum = 0;+
−
	dataifc2().iTotalEndpointsUsed = KObexTotalEndpoints;+
−
	+
−
	// Indicate that this interface does not expect any control transfers +
−
	// from EP0.+
−
	dataifc2().iFeatureWord |= KUsbcInterfaceInfo_NoEp0RequestsPlease;+
−
		+
−
#ifdef NO_ALTERNATE_USB_INTERFACE_SUPPORT+
−
	// For devices that don't suport alternate interfaces, have to place the "function active"+
−
	// interface at alternate setting 0, although the CDC specification says if should be alternate setting 1+
−
	FLOG(_L("Setting data class interface (no alternate interface support)"));+
−
	+
−
	err = iUsb.SetInterface(0 /*alternate setting*/, dataifc2, iBandwidthPriority);+
−
+
−
	if (err != KErrNone) +
−
		{+
−
		//FTRACE(FPrint(_L("Cannot set data interface (no alternate interface support): error %d"), err));+
−
		LOG1(_L("Cannot set data interface (no alternate interface support): error %d"), err);+
−
		LEAVEIFERRORL(err);+
−
		}+
−
#else+
−
	FLOG(_L("Setting data class interface (alternate setting 1)"));+
−
	+
−
	err = iUsb.SetInterface(1 /*alternate setting*/, dataifc2, iBandwidthPriority); +
−
+
−
	if (err != KErrNone) +
−
		{+
−
		//FTRACE(FPrint(_L("Cannot set data interface (alternate setting 1): error %d"), err));+
−
		LOG1(_L("Cannot set data interface (alternate setting 1): error %d"), err);+
−
		LEAVEIFERRORL(err);+
−
		}+
−
+
−
	CleanupStack::Pop(); // ReleaseInterface0+
−
#endif+
−
+
−
	FLOG(_L("CObexUsbHandler::RegInterfacesL - finished."));+
−
	}+
−
+
−
+
−
/**+
−
Utility function which releases the first alternate setting of the specified+
−
interface. Used when setting up Obex interfaces.+
−
+
−
@param	aInterface	The interface to release+
−
*/+
−
void CObexUsbHandler::CleanupReleaseInterface0(TAny* aInterface)+
−
	{+
−
	reinterpret_cast<RDevUsbcClient*>(aInterface)->ReleaseInterface(0 /*alternate setting*/);+
−
	}+
−
+
−
+
−
/**+
−
Accept an incoming connection.+
−
*/+
−
void CObexUsbHandler::Start()+
−
	{+
−
	LOG_FUNC+
−
+
−
	// Await notification of a state change (this is like waiting for a connect...).+
−
	iUsb.AlternateDeviceStatusNotify(iStatus, iUsbState);+
−
	SetActive();+
−
	}+
−
+
−
	+
−
/**+
−
Utility function to allocate DMA to the bulk endpoints - if they have been requested+
−
This function is called during a connect, once the device is configured,+
−
so if the allocations fail it wont complain in release builds but debug builds will+
−
panic with either EDmaAllocationFailedEndpointIn or EDmaAllocationFailedEndpointOut. +
−
*/+
−
void CObexUsbHandler::AllocateDma()+
−
	{+
−
	LOG_FUNC+
−
+
−
	TUsbDeviceCaps dCaps;+
−
	iUsb.DeviceCaps(dCaps);+
−
	if ((dCaps().iFeatureWord1 & KUsbDevCapsFeatureWord1_EndpointResourceAllocV2) != 0)+
−
		{+
−
		// for resource allocation version2, refer to CObexUsbHandler::RegInterfacesL()+
−
		return;+
−
		}+
−
+
−
	if (iRequestDmaOnInEndpoint)+
−
		{+
−
		TInt err = iUsb.AllocateEndpointResource(KTransmitEndpoint, EUsbcEndpointResourceDMA);+
−
		// The following log message is checked for in the test code - change with caution!+
−
		LOG1(_L("IN Endpoint DMA resource allocation result %d"), err);+
−
		(void)err; // to stop compilers complaining about unused variables+
−
		}+
−
+
−
	if (iRequestDmaOnOutEndpoint)+
−
		{+
−
		TInt err = iUsb.AllocateEndpointResource(KReceiveEndpoint, EUsbcEndpointResourceDMA);+
−
		// The following log message is checked for in the test code - change with caution!+
−
		LOG1(_L("OUT Endpoint DMA resource allocation result %d"), err);+
−
		(void)err; // to stop compilers complaining about unused variables+
−
		}+
−
	}+
−
+
−
+
−
//+
−
+
−
/**+
−
Constructs a CObexUsbStaller object+
−
+
−
@param	aUsb			Reference to a RDevUsbcClient object.+
−
@param	aOwner			Reference to a MObexUsbConnector that owns this handler+
−
+
−
@return	A new CObexUsbStaller object+
−
*/+
−
CObexUsbStaller* CObexUsbStaller::NewL(RDevUsbcClient& aUsb, MObexUsbConnector& aOwner)+
−
	{+
−
	CObexUsbStaller* self = new(ELeave) CObexUsbStaller(aUsb, aOwner);+
−
	return self;+
−
	}+
−
+
−
/**+
−
CObexUsbStaller constructor.+
−
+
−
@param	aUsb			Reference to a RDevUsbcClient object.+
−
@param	aOwner			Reference to a MObexUsbConnector that owns this handler+
−
*/+
−
CObexUsbStaller::CObexUsbStaller(RDevUsbcClient& aUsb, MObexUsbConnector& aOwner)+
−
	: CActive(EPriorityStandard), iUsb(aUsb), iOwner(aOwner)+
−
	{+
−
	CActiveScheduler::Add(this);+
−
	}+
−
+
−
+
−
/**+
−
CObexUsbStaller destructor.+
−
*/+
−
CObexUsbStaller::~CObexUsbStaller()+
−
	{+
−
	Cancel();+
−
	}+
−
+
−
+
−
/**+
−
Starts the staller+
−
*/+
−
void CObexUsbStaller::Start()+
−
	{+
−
	LOG_FUNC+
−
	+
−
	if (!IsActive())+
−
		{+
−
		FLOG(_L("Halting transmit endpoint..."));+
−
		iUsb.HaltEndpoint(KTransmitEndpoint);+
−
		iUsb.EndpointStatusNotify(iStatus, iEndpointStatus);+
−
		SetActive();+
−
		}+
−
	}+
−
	+
−
+
−
/**+
−
Called when the transmit endpoint has changed state+
−
*/+
−
void CObexUsbStaller::RunL()+
−
	{+
−
	LOG_FUNC+
−
	+
−
	TEndpointState endpointState;+
−
	iUsb.EndpointStatus(KTransmitEndpoint, endpointState);	+
−
#ifdef __FLOG_ACTIVE+
−
	switch (endpointState)+
−
		{+
−
		case EEndpointStateNotStalled:+
−
			{+
−
			FLOG(_L("Receive endpoint not stalled"));+
−
			break;+
−
			}+
−
		case EEndpointStateStalled:+
−
			{+
−
			FLOG(_L("Receive endpoint stalled"));+
−
			break;+
−
			}+
−
		case EEndpointStateUnknown:+
−
			{+
−
			FLOG(_L("Receive endpoint unknown state"));+
−
			break;+
−
			}+
−
		}+
−
#endif		 +
−
	if (endpointState == EEndpointStateNotStalled)+
−
		{+
−
		LOG1(_L("CObexUsbStallWatcher::RunL -- endpoint no longer stalled (0x%08x)"), iEndpointStatus);+
−
		iOwner.StallCleared();+
−
		}+
−
	else+
−
		{+
−
		LOG1(_L("CObexUsbStallWatcher::RunL -- endpoint still stalled (0x%08x)"), iEndpointStatus);+
−
		iUsb.EndpointStatusNotify(iStatus, iEndpointStatus);+
−
		SetActive();+
−
		}+
−
	}+
−
+
−
+
−
/**+
−
Standard active object error function.+
−
+
−
@return	KErrNone because currently nothing should cause this to be called.+
−
*/+
−
TInt CObexUsbStaller::RunError(TInt /*aError*/)+
−
	{+
−
	LOG_FUNC+
−
	+
−
	return KErrNone;+
−
	}+
−
	+
−
+
−
/**+
−
Standard active object cancellation function.+
−
*/	+
−
void CObexUsbStaller::DoCancel()+
−
	{+
−
	FLOG(_L("CObexUsbStaller -- Cancelling status notification"));+
−
	iUsb.EndpointStatusNotifyCancel();+
−
	}+
−
	+
−