--- a/usbdrv/peripheral/public/usbcshared.h Tue Aug 31 17:01:47 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,997 +0,0 @@
-// Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).
-// All rights reserved.
-// This component and the accompanying materials are made available
-// under the terms of the License "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:
-// e32\include\drivers\usbcshared.h
-// Kernel side definitions for the USB Device driver stack (PIL + LDD).
-//
-//
-
-/**
- @file usbcshared.h
- @internalTechnology
-*/
-
-#ifndef __USBCSHARED_H__
-#define __USBCSHARED_H__
-
-//#include <drivers/usbcque.h>
-#include <usb/usbcque.h>
-
-// Define here what options are required:
-// (USB_SUPPORTS_CONTROLENDPOINTS and USB_SUPPORTS_SET_DESCRIPTOR_REQUEST
-// have never been tested though...)
-//#define USB_SUPPORTS_CONTROLENDPOINTS
-//#define USB_SUPPORTS_SET_DESCRIPTOR_REQUEST
-
-//#include <drivers/usbcdesc.h>
-#include <usb/usbcdesc.h>
-//#include <drivers/usbotgperipheralcontrolif.h>
-#include <usb/usbotgperipheralcontrolif.h>
-
-#include <usb/usb_peripheral_shai.h>
-#include <usb/usb_charger_detection_shai.h>
-
-#include <usb/usbcontrolxferif.h>
-
-// FIXME: Remove this typedef once PIL and LDD are ready for SHAI
-typedef UsbShai::TUsbPeripheralEvent TUsbcDeviceEvent;
-typedef UsbShai::TUsbPeripheralPacketArray TUsbcPacketArray;
-
-// Forward declaration
-class DControlTransferManager;
-class TUsbcSetup;
-
-// Debug Support
-
-// Use for debugging purposes only (commented out for normal operation):
-//#define USBC_LDD_BUFFER_TRACE
-
-static const char KUsbPILPanicCat[] = "USB PIL FAULT"; // kernel fault category
-_LIT(KUsbPILKillCat, "USB PIL KILL"); // thread kill category
-_LIT(KUsbLDDKillCat, "USB LDD KILL"); // thread kill category
-
-/** Error code for stalled endpoint.
-*/
-const TInt KErrEndpointStall = KErrLocked;
-
-/** Error code for Ep0 write prematurely ended by a host OUT token.
-*/
-const TInt KErrPrematureEnd = KErrDiskFull;
-
-/** The following constants control the buffer arrangement for OUT transfers (IN transfers have only 1
- buffer). The total size of buffering for an OUT endpoint will be number of buffers * buffersize,
- so that, for example, a Bulk OUT endpoint will have KUsbcDmaBufNumBulk * KUsbcDmaBufSzBulk bytes of
- buffering.
- These buffers will be physically contiguous, so that DMA may be used.
- The number of buffers MUST be >=2 - otherwise the buffering scheme won't work.
- The buffer sizes should be an exact fraction of 4kB and the number of buffers such that the
- buffersize * number of buffers is an exact multiple of 4kB, otherwise memory will be wasted.
-*/
-/** Size of a Control ep buffer.
-*/
-const TInt KUsbcDmaBufSzControl = 1024;
-
-/** Size of a Bulk ep buffer.
-*/
-const TInt KUsbcDmaBufSzBulk = 4096;
-
-/** Size of an Interrupt ep buffer.
-*/
-const TInt KUsbcDmaBufSzInterrupt = 4096;
-
-/** Size of an Isochronous ep buffer.
-*/
-const TInt KUsbcDmaBufSzIsochronous = 4096;
-
-/** Number of buffers for Control OUT endpoints.
-*/
-const TInt KUsbcDmaBufNumControl = 2;
-
-/** Number of buffers for Isochronous OUT endpoints.
-*/
-const TInt KUsbcDmaBufNumIsochronous = 2;
-
-/** Number of buffers for Bulk OUT endpoints.
-*/
-const TInt KUsbcDmaBufNumBulk = 2;
-
-/** Number of buffers for Interrupt OUT endpoints.
-*/
-const TInt KUsbcDmaBufNumInterrupt = 2;
-
-/** Maximum buffer number.
-*/
-const TInt KUsbcDmaBufNumMax = MAX4(KUsbcDmaBufNumControl, KUsbcDmaBufNumIsochronous,
- KUsbcDmaBufNumBulk, KUsbcDmaBufNumInterrupt);
-
-/** Maximum number of recorded packets possible.
-*/
-const TUint KUsbcDmaBufMaxPkts = 2;
-
-/** Number of arrays.
-*/
-const TInt KUsbcDmaBufNumArrays = 2;
-
-/** Max size that Ep0 packets might have.
-*/
-const TInt KUsbcBufSzControl = 64;
-
-/** The Ep0 RX data collection buffer area.
- (Arbitrary size, judged to be sufficient for SET_DESCRIPTOR requests)
-*/
-const TInt KUsbcBufSz_Ep0Rx = 1024;
-
-/** The Ep0 TX buffer area.
- (Size sufficient to hold as much data as can be requested via GET_DESCRIPTOR)
-*/
-const TInt KUsbcBufSz_Ep0Tx = 1024 * 64;
-
-
-/** The USB version the stack is compliant with: 2.0 (BCD).
-*/
-const TUint16 KUsbcUsbVersion = 0x0200;
-
-/** Maximum number of endpoints an interface (i.e. LDD) may have.
-*/
-const TInt KUsbcMaxEpNumber = 5;
-
-/** Status FIFO depth; enough for 2 complete configs.
-*/
-const TInt KUsbDeviceStatusQueueDepth = 15;
-
-/** = 'no status info'.
-*/
-const TUint32 KUsbDeviceStatusNull = 0xffffffffu;
-
-/** = 'no buffer available'.
-*/
-const TInt KUsbcInvalidBufferIndex = -1;
-
-/** = 'no packet available'.
-*/
-const TUint KUsbcInvalidPacketIndex = (TUint)(-1);
-
-/** = 'no drainable buffers'.
-*/
-const TInt KUsbcInvalidDrainQueueIndex = -1;
-
-/** Number of possible bandwidth priorities.
-*/
-const TInt KUsbcDmaBufMaxPriorities = 4;
-
-// The following buffer sizes are used within the LDD for the different
-// user-selectable endpoint bandwidth priorities
-// (EUsbcBandwidthOUTDefault/Plus1/Plus2/Maximum + the same for 'IN').
-// These values, in particular those for the Maximum setting, were obtained
-// empirically.
-
-/** Bulk IN buffer sizes for different priorities (4K, 16K, 64K, 512K).
-*/
-const TInt KUsbcDmaBufSizesBulkIN[KUsbcDmaBufMaxPriorities] =
- {KUsbcDmaBufSzBulk, 0x4000, 0x10000, 0x80000};
-
-/** Bulk OUT buffer sizes for different priorities (4K, 16K, 64K, 512K).
-*/
-const TInt KUsbcDmaBufSizesBulkOUT[KUsbcDmaBufMaxPriorities] =
- {KUsbcDmaBufSzBulk, 0x4000, 0x10000, 0x80000};
-
-/** Number of UDCs supported in the system.
- (Support for more than one UDC is preliminary.)
-*/
-const TInt KUsbcMaxUdcs = 2;
-
-/** Number of endpoints a USB device can have.
- (30 regular endpoints + 2 x Ep0)
-*/
-const TInt KUsbcEpArraySize = KUsbcMaxEndpoints + 2;
-
-/** Number of notification requests of the same kind that can be registered at
- a time. As normally not more than one request per kind per LDD is
- permitted, this number is roughly equivalent to the maximum number of LDDs
- that can be operating at the same time.
- This constant is used by the PIL while maintaining its request lists
- (iClientCallbacks, iStatusCallbacks, iEpStatusCallbacks, iOtgCallbacks) to
- ensure that the lists are of a finite length and thus the list traverse
- time is bounded.
- This value is chosen with the maximum number of USB interfaces (not
- settings) allowed by the spec for a single device in mind.
-*/
-const TInt KUsbcMaxListLength = 256;
-
-/**
- * device event FIFO depth, there are 5 different event define currently,
- * 10 should be enough
- */
-const TInt KUsbDeviceEventQueueDepth = 10;
-
-/** USB LDD client callback.
-*/
-class TUsbcClientCallback
- {
-public:
- inline TUsbcClientCallback(DBase* aOwner, TDfcFn aCallback, TInt aPriority);
- inline DBase* Owner() const;
- inline TInt DoCallback();
- inline void Cancel();
- inline void SetDfcQ(TDfcQue* aDfcQ);
-public:
- /** Used by the PIL to queue callback objects into a TSglQue. */
- TSglQueLink iLink;
-private:
- DBase* iOwner;
- TDfc iDfc;
- };
-
-
-/** The endpoint halt/clear_halt status.
-*/
-class TUsbcEndpointStatusCallback
- {
-public:
- inline TUsbcEndpointStatusCallback(DBase* aOwner, TDfcFn aCallback, TInt aPriority);
- inline void SetState(TUint aState);
- inline TUint State() const;
- inline DBase* Owner() const;
- inline TInt DoCallback();
- inline void Cancel();
- inline void SetDfcQ(TDfcQue* aDfcQ);
-public:
- /** Used by the PIL to queue callback objects into a TSglQue. */
- TSglQueLink iLink;
-private:
- DBase* iOwner;
- TDfc iDfc;
- TUint iState;
- };
-
-
-/** Maximum number of device status requests that can be queued at a time.
- The value chosen is thought to be sufficient in all situations.
-*/
-const TInt KUsbcDeviceStateRequests = 8;
-
-
-/** The USB device status.
-*/
-class TUsbcStatusCallback
- {
-public:
- inline TUsbcStatusCallback(DBase* aOwner, TDfcFn aCallback, TInt aPriority);
- inline void SetState(UsbShai::TUsbPeripheralState aState);
- inline UsbShai::TUsbPeripheralState State(TInt aIndex) const;
- inline void ResetState();
- inline DBase* Owner() const;
- inline TInt DoCallback();
- inline void Cancel();
- inline void SetDfcQ(TDfcQue* aDfcQ);
-public:
- /** Used by the PIL to queue callback objects into a TSglQue. */
- TSglQueLink iLink;
-private:
- DBase* iOwner;
- TDfc iDfc;
- UsbShai::TUsbPeripheralState iState[KUsbcDeviceStateRequests];
- };
-
-
-/** A USB transfer request.
-
- @publishedPartner
- @released
-*/
-class TUsbcRequestCallback : public UsbShai::TUsbPeripheralRequest
- {
-public:
- /** @internalTechnology */
- inline TUsbcRequestCallback(const DBase* aOwner, TInt aEndpointNum, TDfcFn aDfcFunc,
- TAny* aEndpoint, TDfcQue* aDfcQ, TInt aPriority);
- /** @internalTechnology */
- inline ~TUsbcRequestCallback();
-
- IMPORT_C void SetRxBufferInfo(TUint8* aBufferStart,
- TUintPtr aBufferAddr,
- TUint32* aPacketIndex,
- TUint32* aPacketSize,
- TInt aLength);
-
- IMPORT_C void SetTxBufferInfo(TUint8* aBufferStart,
- TUintPtr aBufferAddr,
- TInt aLength);
-
- /** @internalTechnology */
- inline void SetTransferDirection(UsbShai::TTransferDirection aTransferDir);
- /** @internalTechnology */
- inline const DBase* Owner() const;
- /** @internalTechnology */
- inline TInt DoCallback();
- /** @internalTechnology */
- inline void Cancel();
-public:
- /** Used by the PIL to queue callback objects into a TSglQue.
- @internalTechnology
- */
- TSglQueLink iLink;
-public:
- /** The endpoint number. */
- const TInt iEndpointNum;
-
- /** Indicates the LDD client for this transfer. */
- const DBase* const iOwner;
- /** DFC, used by PIL to call back the LDD when transfer completes to the LDD. */
- TDfc iDfc;
- };
-
-/** USB On-The-Go feature change callback.
-*/
-class TUsbcOtgFeatureCallback
- {
-public:
- inline TUsbcOtgFeatureCallback(DBase* aOwner, TDfcFn aCallback, TInt aPriority);
- inline void SetFeatures(TUint8 aFeatures);
- inline TUint8 Features() const;
- inline DBase* Owner() const;
- inline TInt DoCallback();
- inline void Cancel();
- inline void SetDfcQ(TDfcQue* aDfcQ);
-public:
- /** Used by the PIL to queue callback objects into a TSglQue. */
- TSglQueLink iLink;
-private:
- DBase* iOwner;
- TDfc iDfc;
- TUint8 iValue;
- };
-
-//
-//########################### Physical Device Driver (PIL + PSL) ######################
-//
-
-class TUsbcLogicalEndpoint;
-
-/** This models a physical (real) endpoint of the UDC.
-*/
-class TUsbcPhysicalEndpoint
- {
-public:
- TUsbcPhysicalEndpoint();
- ~TUsbcPhysicalEndpoint();
- TBool EndpointSuitable(const TUsbcEndpointInfo* aEpInfo, TInt aIfcNumber) const; // Check Todo, SC will pass pointer to derived class
- TInt TypeAvailable(TUint aType) const;
- TInt DirAvailable(TUint aDir) const;
-public:
- /** This endpoint's capabilities. */
- UsbShai::TUsbPeripheralEndpointCaps iCaps;
- /** USB address: 0x00, 0x80, 0x01, 0x81, etc. */
- TUint8 iEndpointAddr;
- /** Pointer to interface # this endpoint has been assigned to. */
- const TUint8* iIfcNumber;
- /** Pointer to corresponding logical endpoint or NULL. */
- const TUsbcLogicalEndpoint* iLEndpoint;
- /** Only used when searching for available endpoints. */
- TBool iSettingReserve;
- /** True if endpoint is halted (i.e. issues STALL handshakes), false otherwise. */
- TBool iHalt;
- };
-
-
-class DUsbClientController;
-class TUsbcInterface;
-
-/** This is a 'logical' endpoint, as used by our device configuration model.
-*/
-class TUsbcLogicalEndpoint
- {
-public:
- TUsbcLogicalEndpoint(DUsbClientController* aController, TUint aEndpointNum,
- const TUsbcEndpointInfo& aEpInfo, TUsbcInterface* aInterface,
- TUsbcPhysicalEndpoint* aPEndpoint); // Check Todo, SC will pass pointer to derived class
- ~TUsbcLogicalEndpoint();
-public:
- /** Pointer to controller object. */
- DUsbClientController* iController;
- /** The virtual (logical) endpoint number. */
- const TInt iLEndpointNum;
- /** This endpoint's info structure. */
- TUsbcEndpointInfo iInfo; // Check Todo, SC will pass pointer to derived class
- /** Stores the endpoint size to be used for FS. */
- TInt iEpSize_Fs;
- /** Stores the endpoint size to be used for HS. */
- TInt iEpSize_Hs;
- /** 'Back' pointer. */
- const TUsbcInterface* iInterface;
- /** Pointer to corresponding physical endpoint, never NULL. */
- TUsbcPhysicalEndpoint* const iPEndpoint;
- };
-
-
-class TUsbcInterfaceSet;
-
-/** This is an 'alternate setting' of an interface.
-*/
-class TUsbcInterface
- {
-public:
- TUsbcInterface(TUsbcInterfaceSet* aIfcSet, TUint8 aSetting, TBool aNoEp0Requests);
- ~TUsbcInterface();
-public:
- /** Array of endpoints making up (belonging to) this setting. */
- RPointerArray<TUsbcLogicalEndpoint> iEndpoints;
- /** 'Back' pointer. */
- TUsbcInterfaceSet* const iInterfaceSet;
- /** bAlternateSetting (zero-based). */
- const TUint8 iSettingCode;
- /** KUsbcInterfaceInfo_NoEp0RequestsPlease: stall non-std Setup requests. */
- const TBool iNoEp0Requests;
- };
-
-
-/** This is an 'interface' (owning 1 or more alternate settings).
-
- @see TUsbcInterface
-*/
-class TUsbcInterfaceSet
- {
-public:
- TUsbcInterfaceSet(const DBase* aClientId, TUint8 aIfcNum);
- ~TUsbcInterfaceSet();
- inline const TUsbcInterface* CurrentInterface() const;
- inline TUsbcInterface* CurrentInterface();
-public:
- /** Array of alternate settings provided by (belonging to) this interface. */
- RPointerArray<TUsbcInterface> iInterfaces;
- /** Pointer to the LDD which created and owns this interface. */
- const DBase* const iClientId;
- /** bInterfaceNumber (zero-based). */
- TUint8 iInterfaceNumber;
- /** bAlternateSetting (zero-based). */
- TUint8 iCurrentInterface;
- };
-
-
-/** This is a 'configuration' of the USB device.
- Currently we support only one configuration.
-*/
-class TUsbcConfiguration
- {
-public:
- TUsbcConfiguration(TUint8 aConfigVal);
- ~TUsbcConfiguration();
-public:
- /** Array of interfaces making up (belonging to) this configuration. */
- RPointerArray<TUsbcInterfaceSet> iInterfaceSets;
- /** bConfigurationValue (one-based). */
- const TUint8 iConfigValue;
- };
-
-
-/** The USB controller's power handler class.
-*/
-NONSHARABLE_CLASS(DUsbcPowerHandler) : public DPowerHandler
- {
-public:
- void PowerUp();
- void PowerDown(TPowerState);
-public:
- DUsbcPowerHandler(DUsbClientController* aController);
-private:
- DUsbClientController* iController;
- };
-
-
-/*
-This is the EndpointInfo class used by the usb shared chunk client driver.
-*/
-
-class TUsbcScEndpointInfo;
-
-
-/**
-Used to represent an array of (or inheriting from) TUsbcEndpointInfo objects.
-
-@see DUsbClientController::SetInterface
-*/
-
-class TUsbcEndpointInfoArray
- {
-public:
- typedef enum {EUsbcEndpointInfo, EUsbcScEndpointInfo} TArrayType;
-
- TUsbcEndpointInfoArray(const TUsbcEndpointInfo* aData, TInt aDataSize=0);
- TUsbcEndpointInfoArray(const TUsbcScEndpointInfo* aData, TInt aDataSize=0);
- inline TUsbcEndpointInfo& operator[](TInt aIndex) const;
-
- TArrayType iType;
-private:
- TUint8* iData;
- TInt iDataSize;
- };
-
-class TUsbPeriDeviceEventQueue
- {
-public:
- TUsbPeriDeviceEventQueue();
-
- void FifoAdd(TUsbcDeviceEvent aDeviceStatus);
- TUsbcDeviceEvent FifoGet();
-
-private:
- TUsbcDeviceEvent iDeviceEventQueue[KUsbDeviceEventQueueDepth];
- TInt iDeviceQueueHead;
- TInt iDeviceQueueTail;
- };
-
-class TUsbcRequestCallback; // todo?? required only for class below
-
-/** The USB Device software controller class.
-
- Implements the platform-independent layer (PIL), and defines the interface to the
- platform-specific layer PSL).
-
- The implementation of the platform-specific layer interfaces with the hardware.
-*/
-NONSHARABLE_CLASS(DUsbClientController) : public DBase,
- public MUsbOtgPeripheralControlIf,
- public UsbShai::MUsbPeripheralPilCallbackIf,
- public MControlTransferIf,
- public UsbShai::MChargerDetectorObserverIf
- {
- friend class UsbShai::UsbPeripheralPil;
- friend class TUsbHostWrapperEntry;
- friend class DUsbcPowerHandler;
- friend TUsbcLogicalEndpoint::~TUsbcLogicalEndpoint();
- //
- // --- Platform Independent Layer (PIL) ---
- //
-
-
-private:
- /**
- * Two-phase constructor used by the friend classes that receive
- * the registration calls for peripheral controllers.
- *
- * @param aPeripheralControllerIf Reference to the Peripheral
- * Controller interface implemented by the registering PSL.
- *
- * @param aProperties Reference to an object describing the
- * static properties of the Peripheral Controller. The PIL
- * layer requires that the supplied reference remains valid
- * indefinitely, as a Peripheral Controller cannot unregister.
- *
- * @param aIsOtgPort ETrue if this Peripheral Controller is part
- * of an OTG port. EFalse otherwise.
- *
- * @return Pointer to a new instance or NULL if failed
- */
- IMPORT_C static DUsbClientController* Create(UsbShai::MPeripheralControllerIf& aPeripheralControllerIf,
- const UsbShai::TPeripheralControllerProperties& aProperties,
- TBool aIsOtgPort);
-
-
-public:
-
- //
- // --- The following functions constitute the PIL interface to the LDD ---
- //
- virtual ~DUsbClientController();
- IMPORT_C void DisableClientStack();
- IMPORT_C void EnableClientStack();
- IMPORT_C TBool IsActive();
- IMPORT_C TInt RegisterClientCallback(TUsbcClientCallback& aCallback);
- IMPORT_C static DUsbClientController* UsbcControllerPointer(TInt aUdc=0);
- IMPORT_C void EndpointCaps(const DBase* aClientId, TDes8 &aCapsBuf) const;
- IMPORT_C void DeviceCaps(const DBase* aClientId, TDes8 &aCapsBuf) const;
- IMPORT_C TInt SetInterface(const DBase* aClientId, DThread* aThread, TInt aInterfaceNum,
- TUsbcClassInfo& aClass, TDesC8* aString, TInt aTotalEndpointsUsed,
- const TUsbcEndpointInfo aEndpointData[], TInt (*aRealEpNumbers)[6],
- TUint32 aFeatureWord);
- IMPORT_C TInt SetInterface(const DBase* aClientId, DThread* aThread,
- TInt aInterfaceNum, TUsbcClassInfo& aClass,
- TDesC8* aString, TInt aTotalEndpointsUsed,
- const TUsbcEndpointInfoArray aEndpointData,
- TInt aRealEpNumbers[], TUint32 aFeatureWord);
- IMPORT_C TInt ReleaseInterface(const DBase* aClientId, TInt aInterfaceNum);
- IMPORT_C TInt ReEnumerate();
- IMPORT_C TInt PowerUpUdc();
- IMPORT_C TInt UsbConnect();
- IMPORT_C TInt UsbDisconnect();
- IMPORT_C TInt RegisterForStatusChange(TUsbcStatusCallback& aCallback);
- IMPORT_C TInt DeRegisterForStatusChange(const DBase* aClientId);
- IMPORT_C TInt RegisterForEndpointStatusChange(TUsbcEndpointStatusCallback& aCallback);
- IMPORT_C TInt DeRegisterForEndpointStatusChange(const DBase* aClientId);
- IMPORT_C TInt GetInterfaceNumber(const DBase* aClientId, TInt& aInterfaceNum) const;
- IMPORT_C TInt DeRegisterClient(const DBase* aClientId);
- IMPORT_C TInt Ep0PacketSize() const;
- IMPORT_C TInt Ep0Stall(const DBase* aClientId);
- IMPORT_C void SendEp0StatusPacket(const DBase* aClientId);
- IMPORT_C UsbShai::TUsbPeripheralState GetDeviceStatus() const;
- IMPORT_C TEndpointState GetEndpointStatus(const DBase* aClientId, TInt aEndpointNum) const;
- IMPORT_C TInt SetupReadBuffer(TUsbcRequestCallback& aCallback);
- IMPORT_C TInt SetupWriteBuffer(TUsbcRequestCallback& aCallback);
- IMPORT_C void CancelReadBuffer(const DBase* aClientId, TInt aRealEndpoint);
- IMPORT_C void CancelWriteBuffer(const DBase* aClientId, TInt aRealEndpoint);
- IMPORT_C TInt HaltEndpoint(const DBase* aClientId, TInt aEndpointNum);
- IMPORT_C TInt ClearHaltEndpoint(const DBase* aClientId, TInt aEndpointNum);
- IMPORT_C TInt SetDeviceControl(const DBase* aClientId);
- IMPORT_C TInt ReleaseDeviceControl(const DBase* aClientId);
- IMPORT_C TUint EndpointZeroMaxPacketSizes() const;
- IMPORT_C TInt SetEndpointZeroMaxPacketSize(TInt aMaxPacketSize);
- IMPORT_C TInt GetDeviceDescriptor(DThread* aThread, TDes8& aDeviceDescriptor);
- IMPORT_C TInt SetDeviceDescriptor(DThread* aThread, const TDes8& aDeviceDescriptor);
- IMPORT_C TInt GetDeviceDescriptorSize(DThread* aThread, TDes8& aSize);
- IMPORT_C TInt GetConfigurationDescriptor(DThread* aThread, TDes8& aConfigurationDescriptor);
- IMPORT_C TInt SetConfigurationDescriptor(DThread* aThread, const TDes8& aConfigurationDescriptor);
- IMPORT_C TInt GetConfigurationDescriptorSize(DThread* aThread, TDes8& aSize);
- IMPORT_C TInt SetOtgDescriptor(DThread* aThread, const TDesC8& aOtgDesc);
- IMPORT_C TInt GetOtgDescriptor(DThread* aThread, TDes8& aOtgDesc) const;
- IMPORT_C TInt GetOtgFeatures(DThread* aThread, TDes8& aFeatures) const;
- IMPORT_C TInt GetCurrentOtgFeatures(TUint8& aFeatures) const;
- IMPORT_C TInt RegisterForOtgFeatureChange(TUsbcOtgFeatureCallback& aCallback);
- IMPORT_C TInt DeRegisterForOtgFeatureChange(const DBase* aClientId);
- IMPORT_C TInt GetInterfaceDescriptor(DThread* aThread, const DBase* aClientId, TInt aSettingNum,
- TDes8& aInterfaceDescriptor);
- IMPORT_C TInt SetInterfaceDescriptor(DThread* aThread, const DBase* aClientId, TInt aSettingNum,
- const TDes8& aInterfaceDescriptor);
- IMPORT_C TInt GetInterfaceDescriptorSize(DThread* aThread, const DBase* aClientId, TInt aSettingNum,
- TDes8& aSize);
- IMPORT_C TInt GetEndpointDescriptor(DThread* aThread, const DBase* aClientId, TInt aSettingNum,
- TInt aEndpointNum, TDes8& aEndpointDescriptor);
- IMPORT_C TInt SetEndpointDescriptor(DThread* aThread, const DBase* aClientId, TInt aSettingNum,
- TInt aEndpointNum, const TDes8& aEndpointDescriptor);
- IMPORT_C TInt GetEndpointDescriptorSize(DThread* aThread, const DBase* aClientId, TInt aSettingNum,
- TInt aEndpointNum, TDes8& aSize);
- IMPORT_C TInt GetDeviceQualifierDescriptor(DThread* aThread, TDes8& aDeviceQualifierDescriptor);
- IMPORT_C TInt SetDeviceQualifierDescriptor(DThread* aThread, const TDes8& aDeviceQualifierDescriptor);
- IMPORT_C TInt GetOtherSpeedConfigurationDescriptor(DThread* aThread, TDes8& aConfigurationDescriptor);
- IMPORT_C TInt SetOtherSpeedConfigurationDescriptor(DThread* aThread, const TDes8& aConfigurationDescriptor);
- IMPORT_C TInt GetCSInterfaceDescriptorBlock(DThread* aThread, const DBase* aClientId, TInt aSettingNum,
- TDes8& aInterfaceDescriptor);
- IMPORT_C TInt SetCSInterfaceDescriptorBlock(DThread* aThread, const DBase* aClientId, TInt aSettingNum,
- const TDes8& aInterfaceDescriptor, TInt aSize);
- IMPORT_C TInt GetCSInterfaceDescriptorBlockSize(DThread* aThread, const DBase* aClientId,
- TInt aSettingNum, TDes8& aSize);
- IMPORT_C TInt GetCSEndpointDescriptorBlock(DThread* aThread, const DBase* aClientId, TInt aSettingNum,
- TInt aEndpointNum, TDes8& aEndpointDescriptor);
- IMPORT_C TInt SetCSEndpointDescriptorBlock(DThread* aThread, const DBase* aClientId, TInt aSettingNum,
- TInt aEndpointNum, const TDes8& aEndpointDescriptor,
- TInt aSize);
- IMPORT_C TInt GetCSEndpointDescriptorBlockSize(DThread* aThread, const DBase* aClientId, TInt aSettingNum,
- TInt aEndpointNum, TDes8& aSize);
- IMPORT_C TInt GetStringDescriptorLangId(DThread* aThread, TDes8& aLangId);
- IMPORT_C TInt SetStringDescriptorLangId(TUint16 aLangId);
- IMPORT_C TInt GetManufacturerStringDescriptor(DThread* aThread, TDes8& aString);
- IMPORT_C TInt SetManufacturerStringDescriptor(DThread* aThread, const TDes8& aString);
- IMPORT_C TInt RemoveManufacturerStringDescriptor();
- IMPORT_C TInt GetProductStringDescriptor(DThread* aThread, TDes8& aString);
- IMPORT_C TInt SetProductStringDescriptor(DThread* aThread, const TDes8& aString);
- IMPORT_C TInt RemoveProductStringDescriptor();
- IMPORT_C TInt GetSerialNumberStringDescriptor(DThread* aThread, TDes8& aString);
- IMPORT_C TInt SetSerialNumberStringDescriptor(DThread* aThread, const TDes8& aString);
- IMPORT_C TInt RemoveSerialNumberStringDescriptor();
- IMPORT_C TInt GetConfigurationStringDescriptor(DThread* aThread, TDes8& aString);
- IMPORT_C TInt SetConfigurationStringDescriptor(DThread* aThread, const TDes8& aString);
- IMPORT_C TInt RemoveConfigurationStringDescriptor();
- IMPORT_C TInt GetStringDescriptor(DThread* aThread, TUint8 aIndex, TDes8& aString);
- IMPORT_C TInt SetStringDescriptor(DThread* aThread, TUint8 aIndex, const TDes8& aString);
- IMPORT_C TInt RemoveStringDescriptor(TUint8 aIndex);
- IMPORT_C TBool QueryEndpointResource(const DBase* aClientId, TInt aEndpointNum,
- TUsbcEndpointResource aResource);
- IMPORT_C TInt EndpointPacketSize(const DBase* aClientId, TInt aEndpointNum);
-
- // Called by LDD
- IMPORT_C TDfcQue* DfcQ(TInt aIndex);
- IMPORT_C void DumpRegisters();
- IMPORT_C TInt SignalRemoteWakeup();
- IMPORT_C TBool CurrentlyUsingHighSpeed();
-
- TInt RegisterUdc(TInt aUdc);
-
-protected:
-
- // From base class MUsbPeripheralPilCallbackIf
- void EnablePeripheralStack();
- void DisablePeripheralStack();
- void SetOtgObserver(MUsbOtgPeripheralObserverIf* aObserver);
-
- // Function derived from MUsbPeripheralPilCallbackIf
- UsbShai::TControlStage EnquireEp0NextStage(const TUint8* aSetupBuf) const;
- TInt Ep0RequestComplete(TInt aRealEndpoint, TInt aCount, TInt aError,UsbShai::TControlPacketType aPktType);
- void EndpointRequestComplete(UsbShai::TUsbPeripheralRequest* aCallback);
- TInt DeviceEventNotification(TUsbcDeviceEvent aEvent);
- void MoveToAddressState();
- TInt ProcessSetConfiguration(const TUsbcSetup& aPacket);
- void HandleHnpRequest(TInt aHnpState);
- void GetEp0RxBufferInfo(TUint8*& aBuffer, TInt& aBufferLen);
- void SetRmWakeupStatusEnabled(TBool aRmEnabled);
- UsbShai::TUsbPeripheralState DeviceStatus() const;
- TBool Ep0ReceivedNonStdRequest();
-
- // Functions derived from MControlTransferIf
- // PSL -> PIL
- void ProcessDataInPacket(TInt aCount,TInt aErrCode);
- void ProcessStatusInPacket(TInt aErrCode);
- void ProcessDataOutPacket(TInt aCount,TInt aErrCode);
- void ProcessStatusOutPacket(TInt aErrCode);
- void ProcessSetupPacket(TInt aCount,TInt aErrCode);
-
- // Request from PIL -> PSL
- TInt ProcessSetupEndpointZeroRead();
- TInt ProcessSetupEndpointZeroWrite(const TUint8* aBuffer, TInt aLength, TBool aZlpReqd=EFalse);
- TInt ProcessSendEp0ZeroByteStatusPacket();
- TInt ProcessStallEndpoint(TInt aRealEndpoint);
-
- // Flow control PIL <--> PSL
- void ProcessEp0SetupPacketProceed();
- void ProcessEp0DataPacketProceed();
-
- // Functions from MChargerDetectorObserverIf
- void NotifyPortType(UsbShai::TPortType aPortType);
- //
- //
- // --- Functions and data members provided by PIL, called by PSL ---
- //
-private:
- struct TUsbPeripheralDescriptorPool
- {
- TUsbcDeviceDescriptor* iDeviceDesc;
- TUsbcConfigDescriptor* iConfigDesc;
- TUsbcLangIdDescriptor* iLangId;
- TUsbcStringDescriptor* iManufacturer;
- TUsbcStringDescriptor* iProduct;
- TUsbcStringDescriptor* iSerialNum;
- TUsbcStringDescriptor* iConfig;
- TUsbcOtgDescriptor* iOtgDesc;
- };
-
-private:
- // Internal functions that used in Construct only
- // This function will new a set of descriptors
- TBool CreateDescriptors(TUsbPeripheralDescriptorPool& aOutput);
-
- TBool Initialise(TUsbPeripheralDescriptorPool& aDescPool,
- const UsbShai::TUsbPeripheralEndpointCaps* aEndpointCaps,
- TInt aTotalEndpoint);
-
- DUsbClientController(UsbShai::MPeripheralControllerIf& aPeripheralControllerIf,
- const UsbShai::TPeripheralControllerProperties& aProperties,
- TBool aIsOtgPort);
-
- TInt Construct();
-
- void ProcessStandardRequest(TInt aCount,const TUsbcSetup& aPacket);
- void ProcessNonStandardRequest(TInt aCount,const TUsbcSetup& aPacket);
-
- const DBase* FindNonStandardRequestClient(TUint8 aPacketTypeDestination,const TUsbcSetup& aPacket);
-
- TInt SetupEp0StateMachine();
-
-private:
-
- /** This info can be used by the PSL before sending ZLPs.
-
- @publishedPartner @released
- */
- TBool iEp0ReceivedNonStdRequest;
-
- /** True if RMW is currently enabled (set by either PIL or PSL).
-
- @publishedPartner @released
- */
- TBool iRmWakeupStatus_Enabled;
-
- /** Ep0 incoming (rx) data is placed here (one packet).
-
- @publishedPartner @released
- */
- TUint8 iEp0_RxBuf[KUsbcBufSzControl];
-
-private:
-
- //
- // --- Private member functions (used by PIL) ---
- //
- TInt DeRegisterClientCallback(const DBase* aClientId);
- TBool CheckEpAvailability(TInt aEndpointsUsed, const TUsbcEndpointInfoArray& aEndpointData, TInt aIfcNumber)
- const;
- TUsbcInterface* CreateInterface(const DBase* aClientId, TInt aIfc, TUint32 aFeatureWord);
- TInt CreateEndpoints(TUsbcInterface* aIfc, TInt aEndpointsUsed, const TUsbcEndpointInfoArray& aEndpointData,
- TInt *aRealEpNumbers);
- TInt SetupIfcDescriptor(TUsbcInterface* aIfc, TUsbcClassInfo& aClass, DThread* aThread, TDesC8* aString,
- const TUsbcEndpointInfoArray& aEndpointData);
- TInt ClientId2InterfaceNumber(const DBase* aClientId) const;
- TUsbcInterfaceSet* ClientId2InterfacePointer(const DBase* aClientId) const;
- const DBase* InterfaceNumber2ClientId(TInt aIfcSet) const;
- TUsbcInterfaceSet* InterfaceNumber2InterfacePointer(TInt aIfcSet) const;
- inline const DBase* PEndpoint2ClientId(TInt aRealEndpoint) const;
- inline TInt PEndpoint2LEndpoint(TInt aRealEndpoint) const;
- TInt ActivateHardwareController();
- void DeActivateHardwareController();
- void DeleteInterfaceSet(TInt aIfcSet);
- void DeleteInterface(TInt aIfcSet, TInt aIfc);
- void CancelTransferRequests(TInt aRealEndpoint);
- void DeleteRequestCallback(const DBase* aClientId, TInt aEndpointNum, UsbShai::TTransferDirection aTransferDir);
- void DeleteRequestCallbacks(const DBase* aClientId);
- void StatusNotify(UsbShai::TUsbPeripheralState aState, const DBase* aClientId=NULL);
- void EpStatusNotify(TInt aRealEndpoint);
- void OtgFeaturesNotify();
- void RunClientCallbacks();
- void ProcessDataTransferDone(TUsbcRequestCallback& aRcb);
- void NextDeviceState(UsbShai::TUsbPeripheralState aNextState);
- TInt ProcessSuspendEvent();
- TInt ProcessSuspendEventProceed();
- TInt ProcessResumeEvent();
- TInt ProcessResetEvent(TBool aPslUpcall=ETrue);
- TInt ProcessVbusRisenEvent();
- TInt ProcessVbusFallenEvent();
-
- void ProcessGetDeviceStatus(const TUsbcSetup& aPacket);
- void ProcessGetInterfaceStatus(const TUsbcSetup& aPacket);
- void ProcessGetEndpointStatus(const TUsbcSetup& aPacket);
- void ProcessSetClearDevFeature(const TUsbcSetup& aPacket);
- void ProcessSetClearIfcFeature(const TUsbcSetup& aPacket);
- void ProcessSetClearEpFeature(const TUsbcSetup& aPacket);
- void ProcessSetAddress(const TUsbcSetup& aPacket);
- void ProcessGetDescriptor(const TUsbcSetup& aPacket);
- void ProcessSetDescriptor(const TUsbcSetup& aPacket);
- void ProcessGetConfiguration(const TUsbcSetup& aPacket);
- void ProcessGetInterface(const TUsbcSetup& aPacket);
- void ProcessSetInterface(const TUsbcSetup& aPacket);
- void ProcessSynchFrame(const TUsbcSetup& aPacket);
-
- void ProceedSetDescriptor();
- void ProcessDeviceEventNotification(TUsbcDeviceEvent aEvent);
-
- void SetClearHaltFeature(TInt aRealEndpoint, TUint8 aRequest);
- TInt ClearHaltFeature(TInt aRealEndpoint);
- void ChangeConfiguration(TUint16 aValue);
- void InterfaceSetup(TUsbcInterface* aIfc);
- void InterfaceSetTeardown(TUsbcInterfaceSet* aIfc);
- void ChangeInterface(TUsbcInterface* aIfc);
- TInt DoForEveryEndpointInUse(TInt (DUsbClientController::*aFunction)(TInt), TInt& aCount);
- void EnterFullSpeed();
- void EnterHighSpeed();
- TInt EvaluateOtgConnectFlags();
- inline const TUsbcConfiguration* CurrentConfig() const;
- inline TUsbcConfiguration* CurrentConfig();
- inline TBool InterfaceExists(TInt aNumber) const;
- inline TBool EndpointExists(TUint aAddress) const;
- void Buffer2Setup(const TAny* aBuf, TUsbcSetup& aSetup) const;
- inline TUint EpIdx2Addr(TUint aRealEndpoint) const;
- inline TUint EpAddr2Idx(TUint aAddress) const;
- inline void SetEp0DataOutVars(const DBase* aClientId = NULL);
- inline void ResetEp0DataOutVars();
- inline TBool IsInTheStatusList(const TUsbcStatusCallback& aCallback);
- inline TBool IsInTheEpStatusList(const TUsbcEndpointStatusCallback& aCallback);
- inline TBool IsInTheOtgFeatureList(const TUsbcOtgFeatureCallback& aCallback);
- inline TBool IsInTheRequestList(const TUsbcRequestCallback& aCallback);
- static void ReconnectTimerCallback(TAny* aPtr);
- static void CableStatusTimerCallback(TAny* aPtr);
- static void PowerUpDfc(TAny* aPtr);
- static void PowerDownDfc(TAny* aPtr);
- static void DeviceEventNotifyDfc(TAny* aPtr);
- static void ThreadContextFinderDfc(TAny* aPtr);
-
-private:
-
- //
- // --- Private data members ---
- //
-
- static DUsbClientController* UsbClientController[KUsbcMaxUdcs];
-
- TInt iDeviceTotalEndpoints; // number of endpoints reported by PSL
- TInt iDeviceUsableEndpoints; // number of endpoints reported to LDD
-
- UsbShai::TUsbPeripheralState iDeviceState; // states as of USB spec chapter 9.1
- UsbShai::TUsbPeripheralState iDeviceStateB4Suspend; // state before entering suspend state
-
- TBool iSelfPowered; // true if device is capable of beeing self-powered
- TBool iRemoteWakeup; // true if device is capable of signalling rmwakeup
- TBool iHardwareActivated; // true if controller silicon is in operating state
- TBool iOtgSupport; // true if OTG is supported by this device
- TUint8 iOtgFuncMap; // bitmap indicating OTG extension features
- TBool iHighSpeed; // true if currently operating at high-speed
-
- TInt iEp0MaxPacketSize; // currently configured max packet size for Ep0
- const DBase* iEp0ClientId; // see comment at the begin of ps_usbc.cpp
- TUint16 iEp0DataReceived; // indicates how many bytes have already been received
- TBool iEp0WritePending; // true if a write on ep0 has been set up
- TBool iEp0ClientDataTransmitting; // true if ep0's in DATA_IN on behalf of a client
- const DBase* iEp0DeviceControl; // Device Ep0 requests are delivered to this LDD
-
- TUsbcDescriptorPool iDescriptors; // the descriptors as of USB spec chapter 9.5
- TUint8 iCurrentConfig; // bConfigurationValue of current Config (1-based!)
- RPointerArray<TUsbcConfiguration> iConfigs; // the root of the modelled USB device
- TUsbcPhysicalEndpoint iRealEndpoints[KUsbcEpArraySize]; // array will be filled once at startup
- TUint8 iEp0_TxBuf[KUsbcBufSz_Ep0Tx]; // ep0 outgoing (tx) data is placed here
-#ifdef USB_SUPPORTS_SET_DESCRIPTOR_REQUEST
- TUint8 iEp0_RxCollectionBuf[KUsbcBufSz_Ep0Rx]; // used for (optional) SET_DESCRIPTOR request
-#endif
- TInt iEp0_RxExtraCount; // number of bytes received but not yet delivered
- TBool iEp0_RxExtraData; // true if iEp0_RxExtraCount is valid
- TInt iEp0_TxNonStdCount; // number of bytes requested by non-std Ep0 request
-
- TUsbcRequestCallback* iRequestCallbacks[KUsbcEpArraySize]; // xfer requests; indexed by real ep number
- TSglQue<TUsbcRequestCallback> iEp0ReadRequestCallbacks; // list of ep0 read requests
- TSglQue<TUsbcClientCallback> iClientCallbacks; // registered LDD clients and their callback functions
- TSglQue<TUsbcStatusCallback> iStatusCallbacks; // list of device state notification requests
- TSglQue<TUsbcEndpointStatusCallback> iEpStatusCallbacks; // list of endpoint state notification requests
- TSglQue<TUsbcOtgFeatureCallback> iOtgCallbacks; // list of OTG feature change requests
-
- NTimer iReconnectTimer; // implements USB re-enumeration delay
- NTimer iCableStatusTimer; // implements USB cable status detection delay
- DUsbcPowerHandler* iPowerHandler; // pointer to USB power handler object
- TSpinLock iUsbLock; // implement SMP for USB PDD and LDD
- NFastMutex iMutex; // To pretect interface set with NFastMutex
- UsbShai::MPeripheralControllerIf& iController; // PSL code
-
- const UsbShai::TPeripheralControllerProperties& iControllerProperties; // Static configuration from PSL
- TBool iIsOtgPort; // Is this instance a driver for otg port,
- // Set at construction time.
-
- /**
- * Pointer to the currently set OTG Observer, if any. Not owned.
- */
- MUsbOtgPeripheralObserverIf* iOtgObserver; // Otg interface which is used to listen event from DeviceEventNotification
-
- DControlTransferManager* iConTransferMgr; // Usb Control transfer manager, responsible for chaptor9
-
- TInt iLastError; // Used by chaptor9 sm. No else.
- TBool iSetupPacketPending; // Indicate whether the no-req-callback data is a setup packet
-
- TUsbPeriDeviceEventQueue iDevEventQueue; // PSL can call DeviceEventNotification(...) at any context,
- // but for PIL, we want to serialize the execution of each event
-
- // The thread context for the DfcQ pass by PSL to us.
- NThread* iCommonDfcQThread;
-
-protected:
- TDfc iPowerUpDfc; // queued by power handler upon power-up
- TDfc iPowerDownDfc; // queued by power handler upon power-down
- TDfc iDeviceEventNotifyDfc; // queued by device event notification
- TDfc iThreadContextFinder; // this is used to find which thread does the DfcQ passed by PSL
- // is runing.
-
-private:
- TBool iStandby; // toggled by power handler as appropriate
- TBool iStackIsActive; // client stack's function is usable
- TBool iClientSupportReady; // user-side USB Client support is loaded & active
- TBool iUsbResetDeferred; // set when user-side wasn't ready yet
-
-public:
- // FIXME: These used to be filled by the OTG component Dummy DCD
- // so that the PIL layer can call it to enable and disable the D+
- // pull-up. This mechanism is no longer used
- TInt (*iEnablePullUpOnDPlus)(TAny* aOtgContext);
- TInt (*iDisablePullUpOnDPlus)(TAny* aOtgContext);
- TAny* iOtgContext;
- };
-
-/** Simple queue of status changes to be recorded.
- Items are fetched by userside when able.
-*/
-class TUsbcDeviceStatusQueue
- {
-public:
- TUsbcDeviceStatusQueue();
- void AddStatusToQueue(TUint32 aDeviceStatus);
- TInt GetDeviceQueuedStatus(TUint32& aDeviceStatus);
- void FlushQueue();
-
-private:
- TUint32 iDeviceStatusQueue[KUsbDeviceStatusQueueDepth];
- TInt iStatusQueueHead;
- };
-
-#include <usb/usbcshared.inl>
-
-#endif // __USBCSHARED_H__