diff -r 4dc88a4ac6f4 -r f6055a57ae18 obex/obexprotocol/obexusbtransport/inc/usbconn.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/obex/obexprotocol/obexusbtransport/inc/usbconn.h Tue Oct 19 11:00:12 2010 +0800 @@ -0,0 +1,297 @@ +// 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 +*/ + + +#ifndef __USBCONN_H__ +#define __USBCONN_H__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "ObexUsbTransportController.h" + +// +// LDD name +// +_LIT(KUsbLddName, "eusbc"); + +// Transmit and receive endpoints +// Note that these are the virtual endpoint numbers for the bulk interface and +// should be put in the same order in the TUsbcEndpointInfo array in RegInterfacesL +const TEndpointNumber KTransmitEndpoint = EEndpoint1; +const TEndpointNumber KReceiveEndpoint = EEndpoint2; + +// These are taken from section 6.5 of the WMCDC spec. +const TUint KObexDescriptorLength = 18; +const TUint KObexMinNumEndpoints = 3; +const TUint KObexClassNumber = 0x02; +const TUint KObexNumInterfaces = 2; +const TUint KObexSubClassNumber = 0x0b; +const TUint KObexProtocolNumber = 0x0; +const TUint KObexTotalEndpoints = 2; + +const TUint KObexDataClass = 0x0A; +const TUint KObexDataSubClass = 0; +const TUint KObexAlt0 = 0; +const TUint KObexAlt1 = 1; +const TUint KObexFunctionalDescriptorLength = 5; +const TUint KObexDefaultInterfaceDescriptorLength = 100; //Default value used prior to OS 9.2 +const TUint KObexInterfaceDescriptorBlockLength = 16; + +const TUint8 KCdcVersionNumber[2] = { 0x10, 0x01 }; // CDC v1.1 +const TUint8 KHeaderFunctionalDescriptor = 0x00; +const TUint8 KObexFunctionalDescriptor = 0x15; +const TUint8 KWmcdcVersionNumber[2] = { 0x00, 0x01 }; // WMCDC v1.0 +const TUint8 KUnionFunctionalDescriptor = 0x06; + +const TInt KMaxPacketTypeBulkFS = 64; +const TInt KMaxPacketTypeBulkHS = 512; + + +/** +USB Active Writer class +*/ +NONSHARABLE_CLASS(CObexUsbActiveWriter) : public CObexWriterBase +//------------------------------------------------------------------------------------ + { +public: + static CObexUsbActiveWriter* NewL(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb, TObexConnectionInfo& aInfo, TInt aPacketSize); + ~CObexUsbActiveWriter(); + +private: + virtual void DoCancel(); + virtual void DoTransfer(); + +private: + CObexUsbActiveWriter(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb, TObexConnectionInfo& aInfo, TInt aPacketSize); + +private: + RDevUsbcClient& iUsb; // USB logical device driver + TInt iPacketSize; + }; + + +/** +USB Active Reader class +*/ +NONSHARABLE_CLASS(CObexUsbActiveReader) : public CObexReaderBase +//------------------------------------------------------------------------------------ + { +public: + static CObexUsbActiveReader* NewL(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb, TObexConnectionInfo& aInfo); + ~CObexUsbActiveReader(); + +private: + virtual void DoCancel(); + virtual void DoTransfer(); + virtual TInt GetMaxPacketSize(); + virtual TInt GetInitialPacketSize(); +private: + CObexUsbActiveReader(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb, TObexConnectionInfo& aInfo); +private: + RDevUsbcClient& iUsb; // USB logical device driver + TBool iGotHeader; + }; + + +/** +Used by the USB underlying object to notify changes in the transport link. +*/ +NONSHARABLE_CLASS(MObexUsbConnector) +//------------------------------------------------------------------------------------ + { +public: + /** + @internalComponent + Called in response to the USB transport coming up. + */ + virtual void TransportUp() =0; + + /** + @internalComponent + Called in response to the USB transport going down. + @param aErr An error value associated with the transport down event. + */ + virtual void TransportDown(TInt aErr = KErrDisconnected) =0; + + /** + @internalComponent + Called when an endpoint stall has been cleared. + */ + virtual void StallCleared() =0; + }; + + +/** +Handles the underlying details of a USB connection. Monitors the state of +the transport and notifies owner as transport goes up and down. +*/ +NONSHARABLE_CLASS(CObexUsbHandler) : public CActive +//------------------------------------------------------------------------------------ + { +public: + virtual ~CObexUsbHandler(); + + static CObexUsbHandler* NewL(TObexUsbTransportInfo& aUsbTransportInfo, + MObexUsbConnector& aOwner, RDevUsbcClient& aUsb); + + void Start(); + + // Implements CActive + void RunL(); + TInt RunError(TInt /*aError*/); + +private: + CObexUsbHandler(TObexUsbTransportInfo& aUsbProtocolInfo, MObexUsbConnector& aOwner, RDevUsbcClient& aUsb); + void DoCancel(); + void ConstructL(); + void RegInterfacesL(); + void AllocateDma(); + static void CleanupReleaseInterface0(TAny* aInterface); + +private: + TObexUsbTransportInfo& iObexTransportInfo; // Note: Cannot assume this is valid outside of construction phases + MObexUsbConnector& iOwner; + + RDevUsbcClient& iUsb; // USB LDD used for Data Class interface + RDevUsbcClient iUsbComms; // USB LDD used for Comms Class interface + + TUint iUsbState; // Used by RDevUsbcClient::AlternateDeviceStatusNotify() + TBool iTransportUp; // TRUE when device is configured + + // Interface performance configuration parameters + // (for extended USB Client Driver API) + TInt iBandwidthPriority; + TBool iRequestDmaOnOutEndpoint; + TBool iRequestDmaOnInEndpoint; + }; + + +/** +Class to stall then monitor an endpoint and notify owner when the halt state has been cleared. +*/ +NONSHARABLE_CLASS(CObexUsbStaller) : public CActive +//------------------------------------------------------------------------------------ + { +public: + static CObexUsbStaller* NewL(RDevUsbcClient& aUsb, MObexUsbConnector& iOwner); + ~CObexUsbStaller(); + + void Start(); + +private: + CObexUsbStaller(RDevUsbcClient& aUsb, MObexUsbConnector& iOwner); + + virtual void DoCancel(); + virtual TInt RunError(TInt /*aError*/); + virtual void RunL(); + +private: + RDevUsbcClient& iUsb; + MObexUsbConnector& iOwner; + TUint iEndpointStatus; + }; + + +/** +Class to support connecting to other USB devices. +Server mode is relatively straightforward as this corresponds +exactly to how USB works from the device perspective. Obex client +support though requires some 'magic'. +*/ +NONSHARABLE_CLASS(CObexUsbConnector) : public CObexConnector, public MObexUsbConnector +//------------------------------------------------------------------------------------ + { +public: + /** + This enum holds the three different states which the connector + can be in. In DefaultClient mode, the connector is behaving as + a client but can be switched to server behaviour. Once the mode + has been moved out of DefaultClient (to either Client or Server), + the mode is locked for the lifetime of the object. Other + connectors can provide different behaviour for other CObexServer + or CObexClient objects. + */ + enum TObexUsbMode + { + EDefaultClient, + EClient, + EServer + }; + static CObexUsbConnector* NewL(MObexTransportNotify& aOwner, TObexUsbTransportInfo& aUsbTransportInfo); + CObexUsbConnector (MObexTransportNotify& aOwner, TObexUsbTransportInfo& aUsbTransportInfo); + + ~CObexUsbConnector(); + + virtual void ConstructL(); + + //Implement MObexUsbConnector interface + virtual void TransportUp(); + virtual void TransportDown(TInt aErr = KErrDisconnected); + virtual void StallCleared(); + + //Overrides for pure virtuals in CObexConnector + virtual void ConnectL(); + virtual void CancelConnect(); + virtual void AcceptL(); + virtual void CancelAccept(); + virtual TBool BringTransportDown(); + virtual void SignalTransportError(); + + //required to pass the RDevUsbcClient to the activer reader and writer + RDevUsbcClient* TransportObject(); + TInt GetTransportPacketSize(); + +private: + void OpenUsbL(TInt aUnit); + static TInt LinkUp(TAny* aConn); + static TInt NoDevice(TAny* aConn); + void SignalUp(); + void SignalDown(TInt aErr); + + void ResetTransportPacketSize(); + void SetTransportPacketSize(); + +// Data +private: + RDevUsbcClient iUsb; // USB logical device driver + // Note: This is the handle used for reads and writes. + TObexUsbTransportInfo& iObexTransportInfo; // Reference to protocol info to pass on to CObexUsbHandler + // Note: Cannot assume this is valid outside of construction phases + TObexUsbMode iMode; + + CAsyncCallBack* iCallback; + TBool iTransportLinkAvailable; + TBool iConnectRequested; + TBool iWaitingForLink; + CObexUsbHandler* iHandler; + CObexUsbStaller* iStaller; + + TInt iPacketSize; + }; + + +#endif /* __USBCONN_H__ */