/*

* Copyright (c) 2010 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:

* e32\include\drivers\usbcsc.h

* Kernel side definitions for the USB Device driver stack (PIL + LDD).

*

*/

/**

 @file usbcsc.h

 @internalTechnology

*/

#ifndef __USBCSC_H__

#define __USBCSC_H__

#include <kernel/kernel.h>

#include <kernel/kern_priv.h>

#include <kernel/kpower.h>

#include <platform.h>

#include <usb/d32usbcsc.h>

// #include <drivers/usbcshared.h>

#include <usb/usbcshared.h>

/** LDD Major version, This should agree with the information in RDevUsbcClient::TVer.

*/

const TInt KUsbcScMajorVersion = 0;

/** LDD Minor version, This should agree with the information in RDevUsbcClient::TVer.

*/

const TInt KUsbcScMinorVersion = 1;

/** LDD Build version, This should agree with the information in RDevUsbcClient::TVer.

*/

const TInt KUsbcScBuildVersion = KE32BuildVersionNumber;

/** Must correspond to the max enum of TRequest + 1;

    currently this is ERequestOtgFeaturesNotify = 10.

*/

const TInt KUsbcScMaxRequests = 11;

// Request queue sizes need to be power of 2.

/** The number of requests that can be queued on any IN endpoint */

const TInt KUsbcScInRequests = 4;

/** The number of requests that can be queued on any OUT endpoint */

const TInt KUsbcScOutRequests = 2;

/** In TUsbcScBuffer.iDirection, this indicates that the endpoint is an IN endpoint */

const TInt KUsbcScIn =  0;

/** In TUsbcScBuffer.iDirection, this indicates that the endpoint is an OUT endpoint */

const TInt KUsbcScOut = 1;

/** In TUsbcScBuffer.iDirection, this indicates that the endpoint is an Bidirectional endpoint

currently operating as an IN endpoint */

const TInt KUsbcScBiIn = 2;

/** In TUsbcScBuffer.iDirection, this indicates that the endpoint is an Bidirectional endpoint

currently operating as an OUT endpoint */

const TInt KUsbcScBiOut = 3;

/** The number of directions supported for endpoints, other then EP0.  Currently 2, IN and OUT. */

const TInt KUsbcScDirections = 2;

/** In TUsbcScBuffer::iDirection, this indicates that the endpoint direction is Unknown. */

const TInt KUsbcScUnknown = 4;

const TInt KPageSize = 0x1000;

/** The default buffer size requested for a endpoint, if the user app does not specify a size.*/

const TInt KUsbcScDefaultBufferSize = 0x10000; // 64k

/** The size of the unmapped region of memory between endpoint buffers.

This serves as a guard region, making memory over/under runs more obviose.*/

const TInt KGuardSize = KPageSize;

/** The size put aside for the chunk header structre.*/

const TInt KHeaderSize = KPageSize;

/** For buffers of size >= KUsbScBigBuffIs, The smallest unit of continiouse memory that will be used.

No read will be set up smaller then this, to avoid overly fragmenting the data.

*/

const TInt KUsbSc_BigBuff_MinimumRamRun = KPageSize;

/** For buffers of size < KUsbScBigBuffIs, The smallest unit of continiouse memory that will be used.

No read will be set up smaller then this, to avoid overly fragmenting the data.*/

const TInt KUsbSc_SmallBuff_MinimumRamRun = 1024;

/** The size a buffer request has to be to switch to using KUsbSc_BigBuff_MinimumRamRun.

If the requested buffer is smaller, then the smallest memory allocated to a buffer is KPageSize*/

const TInt KUsbScBigBuffIs = KPageSize*6;

// EP0 is mapped manually, unlike the other endpoints.

/** The position, within the chunk, that the EP0 IN buffer appears*/

const TInt KUsbScEP0InBufPos = 0x800;

/** The position, within the chunk, that the EP0 IN buffer ends*/

const TInt KUsbScEP0InBufEnd = KUsbScEP0InBufPos + 0x400;

// Its better for Out to go 2nd, so gaurd page after it.

/** The position, within the chunk, that the EP0 OUT buffer appears*/

const TInt KUsbScEP0OutBufPos = 0xc00;

/** The position, within the chunk, that the EP0 OUT buffer ends*/

const TInt KUsbScEP0OutBufEnd = KUsbScEP0OutBufPos + 0x400;

/** The number of the entry within the chunk BufferRecord table, for the OUT ep0 buffer.*/

const TInt KUsbcScEp0OutBuff = 0;

/** The number of the entry within the chunk BufferRecord table, for the IN ep0 buffer.*/

const TInt KUsbcScEp0InBuff = 1;

//

//########################### Logical Device Driver (LDD) #############################

//

/** USB LDD factory class.

*/

class DUsbcScLogDevice : public DLogicalDevice

    {

public:

    DUsbcScLogDevice();

    virtual TInt Install();

    virtual void GetCaps(TDes8& aDes) const;

    virtual TInt Create(DLogicalChannelBase*& aChannel);

    };

class DLddUsbcScChannel;

class TUsbcScBuffer;

/** Endpoint tracking for the LDD buffering etc.

*/

class TUsbcScEndpoint

    {

public:

    TUsbcScEndpoint(DLddUsbcScChannel* aLDD, DUsbClientController* aController,

                  const TUsbcScEndpointInfo* aEndpointInfo, TInt aEndpointNum

                  );

    ~TUsbcScEndpoint();

    TInt Construct();

    void CancelTransfer(DThread* aThread);

    void AbortTransfer();

    inline TUsbcScEndpointInfo* EndpointInfo();

    inline TInt RxBytesAvailable() const;

    inline void ResetTransferInfo();

    inline void SetClientReadPending(TBool aVal);

    inline void SetClientWritePending(TBool aVal);

    inline TBool ClientWritePending();

    inline TBool ClientReadPending();

    inline void SetRealEpNumber(TInt aRealEpNumber);

    inline TInt RealEpNumber() const;

    inline TInt EpNumber() const;

    inline void StartBuffer();

    inline void SetBuffer(TUsbcScBuffer* aBuffer);

    inline TUsbcScBuffer* GetBuffer();

private:

    static void RequestCallback(TAny* aTUsbcScEndpoint);

    void TxComplete();

    TInt RxComplete(TBool aReEntrant);

    void RxCompleteNow();

public:

    TUsbcRequestCallback* iRequestCallbackInfo;

private:

    DUsbClientController* iController;

    TUsbcScEndpointInfo iEndpointInfo;

    TBool iClientReadPending;

    TBool iClientWritePending;

    TInt iEndpointNumber;

    TInt iRealEpNumber;

    DLddUsbcScChannel* iLdd;

    TInt iError;

    TUint32 iBytesTransferred;

    TInt iBandwidthPriority;

    TUsbcScBuffer* iBuffer;

    };

/** Linked list of 'alternate setting' info for use by the LDD.

*/

class TUsbcScAlternateSetting

    {

public:

    TUsbcScAlternateSetting();

    ~TUsbcScAlternateSetting();

public:

    TUsbcScAlternateSetting* iNext;

    TUsbcScAlternateSetting* iPrevious;

    TInt iNumberOfEndpoints;

    TUint iSetting;

    TUsbcScEndpoint* iEndpoint[KMaxEndpointsPerClient + 1];

    };

class TUsbcScAlternateSettingList

    {

public:

    TUsbcScAlternateSettingList();

    ~TUsbcScAlternateSettingList();

public:

    TUsbcScAlternateSetting* iHead;

    TUsbcScAlternateSetting* iTail;

    };

class TUsbcScChunkInfo

    {

public:

    TUsbcScChunkInfo(DLogicalDevice* aLdd);

    TInt CreateChunk(TInt aTotalSize);

    void Close();

    TInt ChunkAlloc(TInt aOffset, TInt aSize);

    void ChunkCleanup();

    TInt GetPhysical(TInt aOffset, TPhysAddr* aPhysical);

    static TInt New(TUsbcScChunkInfo*& aChunk, TInt aSize, DLogicalDevice* aLdd);

private:

    TUint* iPhysicalMap;

public:

    DChunk* iChunk;

    TDfc iCleanup;

    TInt8 iPageNtz; // Number of trailing zeros for a page. (Eg 4k page has 12 t.z.)

    TInt iAllocatedSize;

    TInt8* iChunkMem;

    TUint32 iChunkMapAttr;

    DLogicalDevice* iLdd;

    };

// Used to represent a matrix of endpoints with a column of sizes.

// Used by TRealizeInfo

class TEndpointSortBufs

    {

    public:

        TUsbcScEndpoint** iEp;

        TInt* iSizes;

        TInt iEps;

    };

// This is used to calculate the layout of the shared chunk

// based on a list of alternative settings / endpoints provided.

class TRealizeInfo

    {

    public:

        void Init(TUsbcScAlternateSettingList* aAlternateSettingList);

        TInt CopyAndSortEndpoints();

        void CalcBuffSizes();

        void Free();

        void LayoutChunkHeader(TUsbcScChunkInfo* aChunkInfo);

    public:

        TInt iMaxEndpoints;

        TInt iTotalSize;

        TInt iTotalBuffers;

        TInt iAltSettings;

        TEndpointSortBufs iBufs[KUsbcScDirections];

        TUsbcScAlternateSettingList* iAlternateSettingList;

        // Chunk layout info.

        TUsbcScChunkBuffersHeader* iChunkStuct;

        TUsbcScChunkAltSettingHeader* iAltSettingsTbl;

    };

/** The channel class - the actual USB LDD.

*/

class DLddUsbcScChannel : public DLogicalChannel

    {

public:

    DLddUsbcScChannel();

    ~DLddUsbcScChannel();

    virtual void HandleMsg(TMessageBase* aMsg);

    virtual TInt DoCreate(TInt aUnit, const TDesC8* aInfo, const TVersion& aVer);

    virtual TInt RequestUserHandle(DThread* aThread, TOwnerType aType);

    inline DThread* Client() const {return iClient;}

    inline TBool ChannelClosing() const {return iChannelClosing;}

    inline TUint AlternateSetting() const {return iAlternateSetting;}

    static void RequestCallbackEp0(TAny* aTUsbcScChannel);

private:

    TInt DoCancel(TInt aReqNo, TUint aMask, TUint a1);

    TInt DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2);

    TInt DoControl(TInt aFunction, TAny* a1, TAny* a2);

    TInt DoReadDataNotify(TRequestStatus* aStatus, TInt aBufferNum, TInt aLength);

    void StartDataRead(TInt aBufferNum);

    TInt DoWriteData(TRequestStatus* aStatus,TInt aBufferNum, TUint aStart, TUint aLength, TUint aFlags);

    TBool AlternateDeviceStateTestComplete();

    TInt SetInterface(TInt aInterfaceNum, TUsbcScIfcInfo* aUserInterfaceInfoBuf);

    void StartEpReads();

    void DestroyAllInterfaces();

    void DestroyInterface(TUint aInterface);

    void DestroyEp0();

    inline TBool ValidEndpoint(TInt aEndpoint);

    TInt GetRealEpForEpResource(TInt aEndpoint, TInt& aRealEp);

    inline TBool Configured();

    TInt DoEmergencyComplete();

    void ReadDes8(const TAny* aPtr, TDes8& aDes);

    TInt SetupEp0();

    void CancelNotifyEndpointStatus();

    void CancelNotifyOtgFeatures();

    void CancelNotifyChargerType();

    static void StatusChangeCallback(TAny* aDLddUsbcChannel);

    static void EndpointStatusChangeCallback(TAny* aDLddUsbcChannel);

    static void OtgFeatureChangeCallback(TAny* aDLddUsbcChannel);

    static void ChargerTypeChangeCallback(TAny* aDLddUsbcChannel);	

    static void EmergencyCompleteDfc(TAny* aDLddUsbcChannel);

    void DeConfigure(TInt aErrorCode);

    TInt SelectAlternateSetting(TUint aAlternateSetting);

    TInt EpFromAlternateSetting(TUint aAlternateSetting, TInt aEndpoint);

    TInt ProcessAlternateSetting(TUint aAlternateSetting);

    TInt32 StartNextInAlternateSetting();

    TInt ProcessDeviceState(TUsbcDeviceState aDeviceState);

    void ResetInterface(TInt aErrorCode);

    void PanicClientThread(TInt aReason);

    TInt RealizeInterface(void);

private:

    DUsbClientController* iController;

    DThread* iClient;

    TBool iValidInterface;

    TUsbcScAlternateSettingList* iAlternateSettingList;

    TUsbcScEndpoint** iEndpoint;  // Pointer to the current endpoint set.

    static const TInt KUsbcMaxRequests = RDevUsbcScClient::ERequestMaxRequests;

    TRequestStatus* iRequestStatus[KUsbcMaxRequests];

    TUsbcClientCallback iCompleteAllCallbackInfo;

    TAny* iStatusChangePtr;

    TUsbcStatusCallback iStatusCallbackInfo;

    TAny* iEndpointStatusChangePtr;

    TUsbcEndpointStatusCallback iEndpointStatusCallbackInfo;

    TAny* iOtgFeatureChangePtr;

    TUsbcOtgFeatureCallback iOtgFeatureCallbackInfo;

    TAny* iChargerTypeChangePtr;

    TUsbcChargerTypeCallback iChargerTypeCallbackInfo;

    TUint8* iBufferBaseEp0;

    TInt iBufferSizeEp0;

    TInt iNumberOfEndpoints;

    TUsbcDeviceState iDeviceState;

    TUsbcDeviceState iOldDeviceState;

    TBool iOwnsDeviceControl;

    TUint16 iAlternateSetting;

    TUint16 iAsSeq;

    TUsbcDeviceStatusQueue* iStatusFifo;

    TBool iUserKnowsAltSetting;

    TBool iDeviceStatusNeeded;

    TBool iChannelClosing;

    TBool iRealizeCalled;

    TUsbcScChunkInfo* iChunkInfo;

    TInt iNumBuffers;

    TUsbcScBuffer *iBuffers;

    TUsbcScEndpoint* iEp0Endpoint;

    TInt iEP0InBuff;

    TInt iEP0OutBuff;

    friend class TUsbcScBuffer;

    friend void TUsbcScEndpoint::AbortTransfer();

    };

/**

This class is used by TUsbcScStatusList to form a queue of status requests.

These requests are on a buffer basis, so that all buffers can have at least two requests

pending, at the same time. (i.e. buffer 1 could have two requests outstanding, as well as 2 on buffer 2.)

*/

class TUsbcScStatusElement

{

public:

    TRequestStatus* iStatus;

    TInt iLength;

    TUint iStart;

    TUint iFlags;    

};

enum TUsbcScStatusState

{

    ENotRunning,

    EInProgress,

    EReadingAhead,

    EFramgementInProgress

};

class TUsbcScStatusList

{

public:

    TInt Construct(TInt aSize, DThread* aThread);

    void Destroy();

    TUsbcScStatusElement* Next();

    void Pop();

    TInt Add(TRequestStatus* aStatus, TInt aLength, TUint aStart, TUint aFlags);

    void CancelQueued(TInt aErrorCode=KErrCancel);

    TInt Complete(TInt aError);

    void Complete();

public:

    TUsbcScStatusState iState;

private:

    DThread* iClient;

    TInt iHead;   // The element at the head of the queue, ie, the earliest added, and next to be removed.

    TInt iLength; // Length of queue, ie number of elements within

    TInt iSize;   // size of array, ie, max # of requests at a time.

    TUsbcScStatusElement* iElements;

};

/**

This class holds the kernel's copy of all the details related to a shared endpoint buffer,

and provides methods for the LDD to manipulate it.

*/

class TUsbcScBuffer

{

public:

    static const TInt8 KNoEpAssigned=0;

    static const TInt8 KEpIsEnding=1;

    static const TInt8 KEpIsStarting=2;

public:

    TInt Construct(TInt aDirection, DLddUsbcScChannel* aLdd, TInt aBufferOffset, TInt aBufferEndOffset, TInt aMinReadSize, TInt aMaxPacketSize, TInt aMaxReadSize);

    void CreateChunkBufferHeader();

    void StartEndpoint(TUsbcRequestCallback* iRequestInfo, TUint iFlags);

    void Destroy();

    TInt StartDataRead();

    void CompleteRead(TBool aStartNextRead=ETrue);

    void PopStall();

    void StartDataWrite();

    void CompleteWrite();

    void Cancel(TInt aErrorCode);

    void UpdateBufferList(TInt aByteCount,TUint aFlags, TBool aStartNextRead=ETrue);

    void Ep0CancelLddRead();

    void SendEp0StatusPacket(TInt aState);

public:

    TInt8 iDirection;

    TInt8 iMode;

    TInt8 iNeedsPacket;

    TInt8 iReserved;

    DLddUsbcScChannel* iLdd;

    TLinAddr iChunkAddr;

    SUsbcScBufferHeader* iBufferStart;

    TUint iBufferEnd; // One word on from the last word in the buffer.

    TUint iAlignMask;

    TUsbcScStatusList iStatusList;

    TUsbcRequestCallback* iCallback;

    union 

    {

        TInt iHead; // Out endpoints only;

        TUint iSent; // In endpoints only

    };

    TUsbcScChunkInfo* iChunkInfo;

    TInt iMinReadSize;

    TInt iMaxReadSize;

    TInt iMaxPacketSize;  // 0 indicates unconfiured.

    TInt iFirstPacket;

    TInt iStalled;

    // needed for backwards compatibility

    TUsbcPacketArray iIndexArray[KUsbcDmaBufNumMax]; // Has 2 elements

    TUsbcPacketArray iSizeArray[KUsbcDmaBufNumMax];  // Has 2 elements

#ifdef _DEBUG

    TUint iSequence;

#endif

};

#include <usb/usbcsc.inl>

#endif    // __USBCSC_H__