/*

* 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/usbc.h

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

*

*/

/**

 @file usbc.h

 @internalTechnology

*/

#ifndef __USBC_H__

#define __USBC_H__

#include <kernel/kernel.h>

#include <kernel/kern_priv.h>

#include <kernel/kpower.h>

#include <platform.h>

#include <usb/d32usbc.h>

//#include <drivers/usbcshared.h>

#include <usb/usbcshared.h>

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

*/

const TInt KUsbcMajorVersion = 0;

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

*/

const TInt KUsbcMinorVersion = 1;

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

*/

const TInt KUsbcBuildVersion = KE32BuildVersionNumber;

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

    currently this is ERequestOtgFeaturesNotify = 10.

*/

const TInt KUsbcMaxRequests = 12;

//

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

//

/** USB LDD factory class.

*/

class DUsbcLogDevice : public DLogicalDevice

    {

public:

    DUsbcLogDevice();

    virtual TInt Install();

    virtual void GetCaps(TDes8& aDes) const;

    virtual TInt Create(DLogicalChannelBase*& aChannel);

    };

/** OUT buffering is a collection of flat buffers. Each is either fillable or drainable.

    When one buffer becomes full (notified by the PIL) it is marked as not-fillable and the next

    fillable buffer is used. When the buffer has finished draining it is marked as fillable.

*/

class TDmaBuf

    {

public:

    TDmaBuf();

     TDmaBuf(TUsbcEndpointInfo* aEndpointInfo, TInt aBandwidthPriority);

    ~TDmaBuf();

    TInt Construct(TUsbcEndpointInfo* aEndpointInfo);

    TInt BufferTotalSize() const;

    TInt BufferSize() const;

    TInt SetBufferAddr(TInt aBufInd, TUint8* aBufAddr);

    TInt BufferNumber() const;

    void SetMaxPacketSize(TInt aSize);

    void Flush();

    // Rx (OUT) variants

    void RxSetActive();

    void RxSetInActive();

    TBool RxIsActive();

    TBool IsReaderEmpty();

    void ReadXferComplete(TInt aNoBytesRx, TInt aNoPacketsRx, TInt aErrorCode);

    TInt RxCopyDataToClient(DThread* aThread, TClientBuffer *aTcb, TInt aLength, TUint32& aDestOffset,

                            TBool aRUS, TBool& aCompleteNow);

    TInt RxCopyPacketToClient(DThread* aThread,TClientBuffer *aTcb, TInt aLength);

    TInt RxGetNextXfer(TUint8*& aBufferAddr, TUsbcPacketArray*& aIndexArray, TUsbcPacketArray*& aSizeArray,

                       TInt& aLength, TPhysAddr& aBufferPhys);

    TBool RxIsEnoughSpace(TInt aSize);

    inline TInt RxBytesAvailable() const;

    inline void IncrementBufferIndex(TInt& aIndex);

    inline TInt NoRxPackets() const;

    TInt SetDrainable(TInt aBufferNum);

    // Tx (IN) variants

    void TxSetActive();

    void TxSetInActive();

    TBool TxIsActive();

    TInt TxStoreData(DThread* aThread,TClientBuffer *aTcb, TInt aTxLength, TUint32 aBufferOffset);

    TInt TxGetNextXfer(TUint8*& aBufferAddr, TInt& aTxLength, TPhysAddr& aBufferPhys);

    TBool ShortPacketExists();

#if defined(USBC_LDD_BUFFER_TRACE)

    TInt NoRxPacketsAlt() const;

    TInt NoRxBytesAlt() const;

#endif

private:

    TBool AdvancePacket();

    inline TInt GetCurrentError();

    TBool NextDrainableBuffer();

    TBool NextFillableBuffer();

    void FreeDrainedBuffers();

    TInt PeekNextPacketSize();

    TInt PeekNextDrainableBuffer();

    void ModifyTotalRxBytesAvail(TInt aVal);

    void ModifyTotalRxPacketsAvail(TInt aVal);

    void AddToDrainQueue(TInt aBufferIndex);

    inline TInt CopyToUser(DThread* aThread, const TUint8* aSourceAddr, TInt aLength,

                           TClientBuffer *aTcb, TUint32& aDestOffset);

private:

    TInt iExtractOffset;                                    // offset into current packet for data read

    TInt iMaxPacketSize;

    TInt iNumberofBuffers;

    TInt iBufSz;

    TBool iRxActive;

    TBool iTxActive;

    TInt iTotalRxBytesAvail;

    TInt iTotalRxPacketsAvail;

    //

    TUint8* iBufBasePtr;

    TUint8* iCurrentDrainingBuffer;

    TInt iCurrentDrainingBufferIndex;

    TInt iCurrentFillingBufferIndex;

    TUint iCurrentPacket;

    TUsbcPacketArray* iCurrentPacketIndexArray;

    TUsbcPacketArray* iCurrentPacketSizeArray;

    TUint8* iBuffers[KUsbcDmaBufNumMax];

    TBool iDrainable[KUsbcDmaBufNumMax];

    TUsbcPacketArray iPacketInfoStorage[KUsbcDmaBufNumMax * KUsbcDmaBufNumArrays * KUsbcDmaBufMaxPkts];

    TUsbcPacketArray* iPacketIndex[KUsbcDmaBufNumMax];

    TUsbcPacketArray* iPacketSize[KUsbcDmaBufNumMax];

    TUint iNumberofBytesRx[KUsbcDmaBufNumMax];

    TUint iNumberofPacketsRx[KUsbcDmaBufNumMax];

    TInt iError[KUsbcDmaBufNumMax];

    TPhysAddr iBufferPhys[KUsbcDmaBufNumMax];

    TBool iCanBeFreed[KUsbcDmaBufNumMax];

    TInt iDrainQueue[KUsbcDmaBufNumMax + 1];

    TInt iDrainQueueIndex;

    TUint iEndpointType;

#if defined(USBC_LDD_BUFFER_TRACE)

    TInt iFillingOrder;

    TInt iFillingOrderArray[KUsbcDmaBufNumMax];

    TInt iDrainingOrder;

     TUint iNumberofBytesRxRemain[KUsbcDmaBufNumMax];

     TUint iNumberofPacketsRxRemain[KUsbcDmaBufNumMax];

#endif

    };

class DLddUsbcChannel;

/** Endpoint tracking for the LDD buffering etc.

*/

class TUsbcEndpoint

    {

public:

    TUsbcEndpoint();

    TUsbcEndpoint(DLddUsbcChannel* aLDD, DUsbClientController* aController,

                  const TUsbcEndpointInfo* aEndpointInfo, TInt aEndpointNum,

                  TInt aBandwidthPriority);

    ~TUsbcEndpoint();

    TInt Construct();

    TInt TryToStartRead(TBool aReEntrant);

    TInt TryToStartWrite(TEndpointTransferInfo* pTfr);

    TInt CopyToClient(DThread* aThread, TClientBuffer *aTcb);

    TInt CopyToClient(DThread* aClient, TBool& aCompleteNow, TClientBuffer *aTcb);

    TInt ContinueWrite();

    void SetMaxPacketSize(TInt aSize);

    void CancelTransfer(DThread* aThread, TClientBuffer *aTcb);

    void AbortTransfer();

    inline TUsbcEndpointInfo* EndpointInfo();

    inline TInt RxBytesAvailable() const;

    inline TInt BufferSize() const;

    inline TInt SetBufferAddr( TInt aBufInd, TUint8* aAddr);

    inline TInt BufferNumber() const;

    inline void SetTransferInfo(TEndpointTransferInfo* aTransferInfo);

    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;

public:

    TDmaBuf* iDmaBuffers;

private:

    static void RequestCallback(TAny* aTUsbcEndpoint);

    void TxComplete();

    TInt RxComplete(TBool aReEntrant);

    void RxCompleteNow();

    TInt EndpointComplete();

private:

    DUsbClientController* iController;

    TUsbcEndpointInfo iEndpointInfo;

    TEndpointTransferInfo iTransferInfo;

    TBool iClientReadPending;

    TBool iClientWritePending;

    TInt iEndpointNumber;

    TInt iRealEpNumber;

    DLddUsbcChannel* iLdd;

    TInt iError;

    TUsbcRequestCallback* iRequestCallbackInfo;

    TUint32 iBytesTransferred;

    TInt iBandwidthPriority;

    };

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

*/

class TUsbcAlternateSettingList

    {

public:

    TUsbcAlternateSettingList();

    ~TUsbcAlternateSettingList();

public:

    TUsbcAlternateSettingList* iNext;

    TInt iNumberOfEndpoints;

    TUint iSetting;

    TInt iEpNumDeOrderedByBufSize[KMaxEndpointsPerClient + 1];

    TUsbcEndpoint* iEndpoint[KMaxEndpointsPerClient + 1];

    };

struct TClientAsynchNotify

    {

        TClientBufferRequest *iBufferRequest;

        TClientBuffer *iClientBuffer;

        void Reset();

    };

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

*/

class DLddUsbcChannel : public DLogicalChannel

    {

public:

    DLddUsbcChannel();

    ~DLddUsbcChannel();

    virtual TInt SendMsg(TMessageBase * aMsg);

    TInt PreSendRequest(TMessageBase * aMsg,TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2);

    TInt SendControl(TMessageBase* aMsg);

    virtual void HandleMsg(TMessageBase* aMsg);

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

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

    TInt DoRxComplete(TUsbcEndpoint* aTUsbcEndpoint, TInt aEndpoint, TBool aReentrant);

    void DoRxCompleteNow(TUsbcEndpoint* aTUsbcEndpoint, TInt aEndpoint);

    void DoTxComplete(TUsbcEndpoint* aTUsbcEndpoint, TInt aEndpoint, TInt aError);

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

    inline TBool ChannelClosing() const {return iChannelClosing;}

    inline TUint AlternateSetting() const {return iAlternateSetting;}

    TClientBuffer *GetClientBuffer(TInt aEndpoint);

private:

    TInt DoCancel(TInt aReqNo);

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

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

    TInt DoTransferAsyncReq(TInt aEndpointNum, TAny* a1, TAny* a2, TBool& aNeedsCompletion);

    TInt DoOtherAsyncReq(TInt aReqNo, TAny* a1, TAny* a2, TBool& aNeedsCompletion);

    TBool AlternateDeviceStateTestComplete();

    TInt SetInterface(TInt aInterfaceNum, TUsbcIfcInfo* aUserInterfaceInfoBuf);

    void StartEpReads();

    void DestroyAllInterfaces();

    void DestroyInterface(TUint aInterface);

    void DestroyEp0();

    inline TBool ValidEndpoint(TInt aEndpoint);

    TInt DoEmergencyComplete();

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

    TInt SetupEp0();

    DPlatChunkHw* ReAllocate(TInt aBuffersize, DPlatChunkHw* aHwChunk, TUint32 aCacheAttribs);

    DPlatChunkHw* Allocate(TInt aBuffersize, TUint32 aCacheAttribs);

    void ClosePhysicalChunk(DPlatChunkHw* &aHwChunk);

    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);

    TInt ProcessDeviceState(TUsbcDeviceState aDeviceState);

    void ResetInterface(TInt aErrorCode);

    void AbortInterface();

    // Set buffer address of the interface

    void ReSetInterfaceMemory(TUsbcAlternateSettingList* aAlternateSettingListRec,

            RArray<DPlatChunkHw*> &aHwChunks );

    void UpdateEndpointSizes();

    // Check and alloc memory for the interface

    TInt SetupInterfaceMemory(RArray<DPlatChunkHw*> &aHwChunks, 

            TUint32 aCacheAttribs );

    void PanicClientThread(TInt aReason);

    TInt PinMemory(TDesC8 *aDes, TVirtualPinObject *iPinObj); //Descriptor pinning helper.

    void CompleteBufferRequest(DThread* aThread, TInt aReqNo, TInt aReason);

private:

    DUsbClientController* iController;

    DThread* iClient;

    TBool iValidInterface;

    TUsbcAlternateSettingList* iAlternateSettingList;

    TUsbcEndpoint* iEndpoint[KMaxEndpointsPerClient + 1];    // include ep0

    TRequestStatus* iRequestStatus[KUsbcMaxRequests];

    TClientAsynchNotify* iClientAsynchNotify[KUsbcMaxRequests];

    TUsbcClientCallback iCompleteAllCallbackInfo;

    TAny* iStatusChangePtr;

    TUsbcStatusCallback iStatusCallbackInfo;

    TAny* iEndpointStatusChangePtr;

    TUsbcEndpointStatusCallback iEndpointStatusCallbackInfo;

    TAny* iOtgFeatureChangePtr;

    TUsbcOtgFeatureCallback iOtgFeatureCallbackInfo;

    TAny* iChargerTypeChangePtr;

    TUsbcChargerTypeCallback iChargerTypeCallbackInfo;

    TInt iNumberOfEndpoints;

    RArray<DPlatChunkHw*> iHwChunksEp0;

    RArray<DPlatChunkHw*> iHwChunks;

    TUsbcDeviceState iDeviceState;

    TUsbcDeviceState iOldDeviceState;

    TBool iOwnsDeviceControl;

    TUint iAlternateSetting;

    TBool iDeviceStatusNeeded;

    TUsbcDeviceStatusQueue* iStatusFifo;

    TBool iChannelClosing;

    TVirtualPinObject *iPinObj1;

    TVirtualPinObject *iPinObj2;

    TVirtualPinObject *iPinObj3;

    TClientDataRequest<TUint> *iStatusChangeReq;

    TClientDataRequest<TUint> *iEndpointStatusChangeReq;

    TClientDataRequest<TUint> *iOtgFeatureChangeReq;

    TClientDataRequest<TUint> *iChargerTypeChangeReq;

    TEndpointTransferInfo iTfrInfo;

    };

#include <usb/usbc.inl>

#endif    // __USBC_H__