// 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/drivers/usbc/d_usbc.cpp

// LDD for USB Device driver stack:

// The channel object.

// 

//

/**

 @file d_usbc.cpp

 @internalTechnology

*/

#include <usb/usbc.h>

_LIT(KUsbLddName, "Usbc");

static const TInt KUsbRequestCallbackPriority = 2;

// Quick sanity check on endpoint properties

static TBool ValidateEndpoint(const TUsbcEndpointInfo* aEndpointInfo)

    {

    const TUint dir = aEndpointInfo->iDir;

    const TInt size = aEndpointInfo->iSize;

    if (size <= 0)

        return EFalse;

    switch (aEndpointInfo->iType)

        {

    case UsbShai::KUsbEpTypeControl:

        if (dir != UsbShai::KUsbEpDirBidirect || size > 64)

            return EFalse;

        break;

    case UsbShai::KUsbEpTypeIsochronous:

        if ((dir != UsbShai::KUsbEpDirIn && dir != UsbShai::KUsbEpDirOut) || size > 1024)

            return EFalse;

        break;

    case UsbShai::KUsbEpTypeBulk:

        if ((dir != UsbShai::KUsbEpDirIn && dir != UsbShai::KUsbEpDirOut) || size > 512)

            return EFalse;

        break;

    case UsbShai::KUsbEpTypeInterrupt:

        if ((dir != UsbShai::KUsbEpDirIn && dir != UsbShai::KUsbEpDirOut) || size > 1024)

            return EFalse;

        break;

    default:

        return EFalse;

        }

    return ETrue;

    }

/** Real entry point from the Kernel: return a new driver.

 */

DECLARE_STANDARD_LDD()

    {

    return new DUsbcLogDevice;

    }

/** Create a channel on the device.

    @internalComponent

*/

TInt DUsbcLogDevice::Create(DLogicalChannelBase*& aChannel)

    {

    aChannel = new DLddUsbcChannel;

    return aChannel ? KErrNone : KErrNoMemory;

    }

DUsbcLogDevice::DUsbcLogDevice()

      {

      iParseMask = KDeviceAllowUnit;

      iUnitsMask = 0xffffffff;                                // Leave units decision to the Controller

      iVersion = TVersion(KUsbcMajorVersion, KUsbcMinorVersion, KUsbcBuildVersion);

      }

TInt DUsbcLogDevice::Install()

    {

    // Only proceed if we have the Controller underneath us

    if (!DUsbClientController::UsbcControllerPointer())

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("LDD Install: USB Controller Not Present"));

        return KErrGeneral;

        }

    return SetName(&KUsbLddName);

    }

//

// Return the USB controller capabilities.

//

void DUsbcLogDevice::GetCaps(TDes8& aDes) const

    {

    TPckgBuf<TCapsDevUsbc> b;

    b().version = iVersion;

    Kern::InfoCopy(aDes, b);

    }

//

// Constructor

//

DLddUsbcChannel::DLddUsbcChannel()

    : iValidInterface(EFalse),

      iAlternateSettingList(NULL),

      iCompleteAllCallbackInfo(this, DLddUsbcChannel::EmergencyCompleteDfc, KUsbRequestCallbackPriority),

      iStatusChangePtr(NULL),

      iStatusCallbackInfo(this, DLddUsbcChannel::StatusChangeCallback, KUsbRequestCallbackPriority),

      iEndpointStatusChangePtr(NULL),

      iEndpointStatusCallbackInfo(this, DLddUsbcChannel::EndpointStatusChangeCallback,

                                  KUsbRequestCallbackPriority),

      iOtgFeatureChangePtr(NULL),

      iOtgFeatureCallbackInfo(this, DLddUsbcChannel::OtgFeatureChangeCallback, KUsbRequestCallbackPriority),

      iNumberOfEndpoints(0),

      iDeviceState(UsbShai::EUsbPeripheralStateUndefined),

      iOwnsDeviceControl(EFalse),

      iAlternateSetting(0),

      iDeviceStatusNeeded(EFalse),

      iChannelClosing(EFalse)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("*** DLddUsbcChannel::DLddUsbcChannel CTOR"));

    iClient = &Kern::CurrentThread();

    iClient->Open();

    for (TInt i = 1; i <= KMaxEndpointsPerClient; i++)

        {

        iEndpoint[i] = NULL;

        }

    for (TInt i = 1; i < KUsbcMaxRequests; i++)

        {

        iRequestStatus[i] = NULL;

        }

    }

DLddUsbcChannel::~DLddUsbcChannel()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::~DLddUsbcChannel()"));

    if (iController)

        {

        iController->DeRegisterClient(this);

        iStatusCallbackInfo.Cancel();

        iEndpointStatusCallbackInfo.Cancel();

        iOtgFeatureCallbackInfo.Cancel();

        iCompleteAllCallbackInfo.Cancel();

        AbortInterface();

        DestroyAllInterfaces();

        if (iOwnsDeviceControl)

            {

            iController->ReleaseDeviceControl(this);

            iOwnsDeviceControl = EFalse;

            }

        DestroyEp0();

        delete iStatusFifo;

        Kern::DestroyClientRequest(iStatusChangeReq);

        Kern::DestroyClientRequest(iEndpointStatusChangeReq);

        Kern::DestroyClientRequest(iOtgFeatureChangeReq);

        Kern::DestroyVirtualPinObject(iPinObj1);

        Kern::DestroyVirtualPinObject(iPinObj2);

        Kern::DestroyVirtualPinObject(iPinObj3);

        for (TInt i = 0; i < KUsbcMaxRequests; i++)

            {

            Kern::DestroyClientBufferRequest(iClientAsynchNotify[i]->iBufferRequest);

            delete iClientAsynchNotify[i];

            }

        }

    Kern::SafeClose((DObject*&)iClient, NULL);

    }

inline TBool DLddUsbcChannel::ValidEndpoint(TInt aEndpoint)

    {

    return (aEndpoint <= iNumberOfEndpoints && aEndpoint >= 0);

    }

//

// Create channel

//

TInt DLddUsbcChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("LDD DoCreateL 1 Ver = %02d %02d %02d",

                                    aVer.iMajor, aVer.iMinor, aVer.iBuild));

    if (!Kern::CurrentThreadHasCapability(ECapabilityCommDD,

                                          __PLATSEC_DIAGNOSTIC_STRING("Checked by USBC.LDD (USB Driver)")))

        {

        return KErrPermissionDenied;

        }

    iController = DUsbClientController::UsbcControllerPointer();

    if (!iController)

        {

        return KErrGeneral;

        }

    iStatusFifo = new TUsbcDeviceStatusQueue;

    if (iStatusFifo == NULL)

        {

        return KErrNoMemory;

        }

      if (!Kern::QueryVersionSupported(TVersion(KUsbcMajorVersion, KUsbcMinorVersion, KUsbcBuildVersion), aVer))

        {

        return KErrNotSupported;

        }

    // set up the correct DFC queue

    SetDfcQ(iController->DfcQ(0));                            // sets the channel's dfc queue

    #ifdef DFC_REALTIME_STATE

        iDfcQ.SetRealtimeState(ERealtimeStateOn);

    #endif

    iCompleteAllCallbackInfo.SetDfcQ(iDfcQ);

    iStatusCallbackInfo.SetDfcQ(iDfcQ);                        // use the channel's dfcq for this dfc

    iEndpointStatusCallbackInfo.SetDfcQ(iDfcQ);                // use the channel's dfcq for this dfc

    iOtgFeatureCallbackInfo.SetDfcQ(iDfcQ);

    iMsgQ.Receive();                                        //start up the message q

    TInt r = iController->RegisterClientCallback(iCompleteAllCallbackInfo);

    if (r != KErrNone)

        return r;

    r = iController->RegisterForStatusChange(iStatusCallbackInfo);

    if (r != KErrNone)

        return r;

    r = iController->RegisterForEndpointStatusChange(iEndpointStatusCallbackInfo);

    if (r != KErrNone)

        return r;

    r = iController->RegisterForOtgFeatureChange(iOtgFeatureCallbackInfo);

    if (r != KErrNone)

        return r;

    r = Kern::CreateClientDataRequest(iStatusChangeReq);

    if (r != KErrNone)

        return r;

    r = Kern::CreateClientDataRequest(iEndpointStatusChangeReq);

    if (r != KErrNone)

        return r;

    r = Kern::CreateClientDataRequest(iOtgFeatureChangeReq);

    if (r != KErrNone)

        return r;

    Kern::CreateVirtualPinObject(iPinObj1);

    Kern::CreateVirtualPinObject(iPinObj2);

    Kern::CreateVirtualPinObject(iPinObj3);

    for (TInt i = 0; i < KUsbcMaxRequests; i++)

        {

            iClientAsynchNotify[i] = new TClientAsynchNotify;

            if(iClientAsynchNotify[i] == NULL)

                return KErrNoMemory;

            r = Kern::CreateClientBufferRequest(iClientAsynchNotify[i]->iBufferRequest,1,TClientBufferRequest::EPinVirtual);

            if (r != KErrNone)

                {

                delete iClientAsynchNotify[i];

                iClientAsynchNotify[i]=NULL;

                return r;

                }

        }

    return r;

    }

void DLddUsbcChannel::CompleteBufferRequest(DThread* aThread, TInt aReqNo, TInt aReason)

{

    iRequestStatus[aReqNo]=NULL;

    Kern::QueueBufferRequestComplete(aThread, iClientAsynchNotify[aReqNo]->iBufferRequest, aReason);

}

TClientBuffer * DLddUsbcChannel::GetClientBuffer(TInt aEndpoint)

{

    return iClientAsynchNotify[aEndpoint]->iClientBuffer;

}

//Runs in client thread

TInt DLddUsbcChannel::SendMsg(TMessageBase * aMsg)

{

    TThreadMessage& m=* (TThreadMessage*)aMsg;

    TInt id = m.iValue;

    TInt r = KErrNone;

    //Cancel Request

    if (id == KMaxTInt)

        {

            r = DLogicalChannel::SendMsg(aMsg);

            return r;

        }

    if (id < 0)

        {

        // DoRequest

        TRequestStatus* pS = (TRequestStatus*) m.Ptr0();

        r = PreSendRequest(aMsg,~id, pS, m.Ptr1(), m.Ptr2());

        if (r == KErrNone)

            {

            r = DLogicalChannel::SendMsg(aMsg);

            }

        }

    else

        {

        //SendControl

        r = SendControl(aMsg);

        }

    return r;

}

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

{

    TInt r = KErrNone;

    if (aReqNo >= KUsbcMaxRequests)

    {

        Kern::RequestComplete(aStatus, KErrNotSupported);

        return KErrNotSupported;

    }

    if (aReqNo > KUsbcMaxEpNumber)//DoOtherAsyncReq

    {

        switch (aReqNo)

        {

            case RDevUsbcClient::ERequestEndpointStatusNotify:

                iEndpointStatusChangeReq->Reset();

                iEndpointStatusChangeReq->SetStatus(aStatus);

                iEndpointStatusChangeReq->SetDestPtr(a1);

            break;

            case RDevUsbcClient::ERequestOtgFeaturesNotify:

                iOtgFeatureChangeReq->Reset();

                iOtgFeatureChangeReq->SetStatus(aStatus);

                iOtgFeatureChangeReq->SetDestPtr(a1);

            break;

            case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:

                iStatusChangeReq->Reset();

                iStatusChangeReq->SetStatus(aStatus);

                iStatusChangeReq->SetDestPtr(a1);

            break;

            case RDevUsbcClient::ERequestReEnumerate://WE use bufferrequest to complete even tho we dont add any buffers

                iClientAsynchNotify[aReqNo]->Reset();

                r=iClientAsynchNotify[aReqNo]->iBufferRequest->StartSetup(aStatus);

                if (r != KErrNone)

                    return r;

                iClientAsynchNotify[aReqNo]->iBufferRequest->EndSetup();

            break;

        }

    }

    else //DoTransferAsyncReq

    {

            if(a1 == NULL)

                return KErrArgument;

            iClientAsynchNotify[aReqNo]->Reset();

            r=iClientAsynchNotify[aReqNo]->iBufferRequest->StartSetup(aStatus);

            if (r != KErrNone)

                return r;

            kumemget(&iTfrInfo,a1,sizeof(TEndpointTransferInfo));

            r=iClientAsynchNotify[aReqNo]->iBufferRequest->AddBuffer(iClientAsynchNotify[aReqNo]->iClientBuffer, iTfrInfo.iDes);

            if (r != KErrNone)

                return r;

            iClientAsynchNotify[aReqNo]->iBufferRequest->EndSetup();

            TThreadMessage& m=*(TThreadMessage*)aMsg;

            m.iArg[1] = (TAny*)&iTfrInfo; //Use Channel owned TransfereInfo structure 

    }

    return KErrNone;

}

void DLddUsbcChannel::HandleMsg(TMessageBase* aMsg)

    {

    TThreadMessage& m = *(TThreadMessage*)aMsg;

    TInt id = m.iValue;

    if (id == (TInt) ECloseMsg)

        {

        iChannelClosing = ETrue;

        m.Complete(KErrNone, EFalse);

        return;

        }

    else if (id == KMaxTInt)

        {

        // Cancel request

        TInt mask = m.Int0();

        TInt b = 1;

        for(TInt reqNo = 0; reqNo < KUsbcMaxRequests; reqNo++)

            {

            TRequestStatus* pS = iRequestStatus[reqNo];

            if ((mask & b) && (pS != NULL))

                {

                DoCancel(reqNo);

                }

            b <<= 1;

            }

        m.Complete(KErrNone, ETrue);

        return;

        }

    if (id < 0)

        {

        // DoRequest

        TRequestStatus* pS = (TRequestStatus*) m.Ptr0();

        DoRequest(~id, pS, m.Ptr1(), m.Ptr2());

        m.Complete(KErrNone, ETrue);

        }

    else

        {

        // DoControl

        TInt r = DoControl(id, m.Ptr0(), m.Ptr1());

        m.Complete(r, ETrue);

        }

    }

//

// Overriding DObject virtual

//

TInt DLddUsbcChannel::RequestUserHandle(DThread* aThread, TOwnerType /*aType*/)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("DLddUsbcChannel::RequestUserHandle"));

    // The USB client LDD is not designed for a channel to be shared between

    // threads. It saves a pointer to the current thread when it is opened, and

    // uses this to complete any asynchronous requests.

    // It is therefore not acceptable for the handle to be duplicated and used

    // by another thread:

    if (aThread == iClient)

        {

        return KErrNone;

        }

    else

        {

        return KErrAccessDenied;

        }

    }

//

// Asynchronous requests - overriding pure virtual

//

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

    {

    // Check on request status

    __KTRACE_OPT(KUSB, Kern::Printf("DoRequest 0x%08x", aReqNo));

        TInt r = KErrNone;

        if (iRequestStatus[aReqNo] != NULL)

            {

            DestroyAllInterfaces();

            PanicClientThread(ERequestAlreadyPending);

            }

        else

            {

            TBool needsCompletion;

            iRequestStatus[aReqNo] = aStatus;

            if (aReqNo > KUsbcMaxEpNumber)

                {

                r = DoOtherAsyncReq(aReqNo, a1, a2, needsCompletion);

                if (needsCompletion)

                    {

                    switch (aReqNo)

                    {

                        case RDevUsbcClient::ERequestEndpointStatusNotify:

                            iRequestStatus[aReqNo]=NULL;

                            Kern::QueueRequestComplete(iClient,iEndpointStatusChangeReq,r);

                        break;

                        case RDevUsbcClient::ERequestOtgFeaturesNotify:

                            iRequestStatus[aReqNo]=NULL;

                            Kern::QueueRequestComplete(iClient,iOtgFeatureChangeReq,r);

                        break;

                        case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:

                            iRequestStatus[aReqNo]=NULL;

                            Kern::QueueRequestComplete(iClient,iStatusChangeReq,r);

                        break;

                        case RDevUsbcClient::ERequestReEnumerate:

                            iRequestStatus[aReqNo]=NULL;

                            Kern::QueueBufferRequestComplete(iClient, iClientAsynchNotify[aReqNo]->iBufferRequest, r);

                        break;

                    }

                  }

                }

            else

                {

                r = DoTransferAsyncReq(aReqNo, a1, a2, needsCompletion);

                if (needsCompletion)

                    {

                    //Kern::RequestComplete(iClient, iRequestStatus[aReqNo], r);

                    CompleteBufferRequest(iClient, aReqNo, r);

                    }

                }

            }

    }

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

    {

    // The general assumption is that none of these will complete now.

    // However, those that make this function return something other than

    // KErrNone will get completed by the calling function.

    // So, 1) If you are returning KErrNone but really need to complete because

    //        completion criteria can be met (for example, sufficient data is

    //        available in the buffer) and then set aNeedsCompletion = ETrue.

    //     2) Do NOT complete here AT ALL.

    //

    aNeedsCompletion = EFalse;

    TInt r = KErrNone;

    switch (aReqNo)

        {

    case RDevUsbcClient::ERequestAlternateDeviceStatusNotify:

        {

        __KTRACE_OPT(KUSB, Kern::Printf("EControlReqDeviceStatusNotify"));

        if (a1 != NULL)

            {

            iDeviceStatusNeeded = ETrue;

            iStatusChangePtr = a1;

            aNeedsCompletion = AlternateDeviceStateTestComplete();

            }