// 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/usbcc/ps_usbc.cpp

// Platform independent layer (PIL) of the USB Device controller driver (PDD).

// Interface to the USB LDD.

// 

//

/**

 @file ps_usbc.cpp

 @internalTechnology

*/

//#include <drivers/usbc.h>

#include <usb/usbc.h>

#include "controltransfersm.h"

/**

    TUsbcInterfaceSet and TUsbcInterface

    ====================================

    TUsbcInterfaceSet represents a 'USB Interface' and TUsbcInterface

    represents an 'Alternate Setting of a USB Interface'.

    Since every LDD governs exactly one interface, the above distinction is

    made only within the USB implementation. At the LDD API, there is/are

    simply one or more settings for this single interface, numbered from '0'

    (the default) to 'n', and specified by the parameter 'TInt aInterfaceNum'.

    Within the PDD implementation, for a TUsbcInterfaceSet number the parameter

    'TInt aIfcSet' is used (local variable ifcset); for a TUsbcInterface number

    the parameter 'TInt aIfc' is used (local variable ifc).

    iConfigs[0] and CurrentConfig()

    ===============================

    One problem with this file is that it always uses iConfigs[0] and not

    CurrentConfig(). This is mainly because the API to the LDD doesn't know

    about the concept of multiple configurations, and thus always assumes one

    single configuration (which is also always active: a further problem).

    In the file chapter9.cpp this issue doesn't exist, since there we always

    have to obey the USB protocol, and in this way will use the configuration

    which is selected by the host (which will then again currently always be

    iConfigs[0].)

    iEp0ClientId

    ==================================

    The purpose of these two members of class DUsbClientController is the

    following.

    They are used only during Ep0 control transactions which have an OUT (Rx)

    data stage. We cannot deduce from the received data itself to whom

    it is addressed (that's because of the shared nature of Ep0).

    In order to be able to tell whether received Ep0 data is to be processed by

    the PIL or a LDD, we use iEp0ClientId. iEp0ClientId is usually NULL, which

    means it is our data. However it is set to the client ID of an LDD in case

    2) above. That way we can subsequently hand over received data to the

    correct client LDD.

    iEp0DataReceived tracks the amount of data already received - it is used to

    determine the end of the DATA_OUT phase, irrespective of the owner of the

    data. The total amount that is to be received can be obtained via

    iConTransferMgr->PktParser().Length(). (iConTransferMgr->PktParser() holds in 

    that case the Setup packet of the current Control transfer.)

    iEp0ClientDataTransmitting is only set to TRUE if a client sets up an Ep0

    write. After that transmission has completed we use this value to decide

    whether we have to report the completion to a client or not. (If this

    variable is FALSE, we did set up the write and thus no client notification

    is necessary.)

*/

//

// === Global and Local Variables ==================================================================

//

// Currently we support at most 2 peripheral stack

GLDEF_D DUsbClientController* DUsbClientController::UsbClientController[] = {NULL, NULL};

static const TInt KUsbReconnectDelay   = 500;                // milliseconds

// Charger detector is the guy(PSL) who can detect the charger type and report 

// it via a charger type observer

static UsbShai::MChargerDetectorIf* gChargerDetector = NULL;

// Charger observer is the guy who want to monitor the chager type event.

static UsbShai::MChargerDetectorObserverIf* gChargerObsever = NULL;

// Those const variables are used to construct the default 

// Usb descriptors, Upper layer can change them later.

/** Default vendor ID to set in device descriptor */

static const TUint16 KUsbVendorId   = KUsbVendorId_Symbian;

/** Default product ID to set in device descriptor */

static const TUint16 KUsbProductId  = 0x1111;

/** Default language ID (US English) to set in device descriptor */

static const TUint16 KUsbLangId     = 0x0409;

static const TUint8 KUsbNumberOfConfiguration = 0x01;

/** Default manufacturer string */

static const wchar_t KStringManufacturer[] = L"Nokia Corporation";

/** Default product name string */

static const wchar_t KStringProduct[]      = L"Nokia USB Driver";

/** Default configuration name string */

static const wchar_t KStringConfig[]       = L"Bulk transfer method configuration";

/** Default configuration name string */

static const wchar_t KStringSerial[]       = L"Serial Not defined";

//

// === USB Controller member function implementations - LDD API (public) ===========================

//

DECLARE_STANDARD_EXTENSION()//lint !e1717 !e960 defined by symbian

    {

    __KTRACE_OPT(KUSB, Kern::Printf("> Peripheral PIL Extension entry"));

    // Don't need to do anything here, using extension just to make sure

    // we're loaded when peripheral PSL trying to register itself to us.

    __KTRACE_OPT(KUSB, Kern::Printf("< Peripheral PIL Extension exit"));

    return KErrNone;

    }

/** The class destructor.

    This rarely gets called, except, for example when something goes

    wrong during construction.

    It's not exported because it is virtual.

*/

DUsbClientController::~DUsbClientController()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::~DUsbClientController()"));

    if (iPowerHandler)

        {

        iPowerHandler->Remove();

        delete iPowerHandler;

        }

    // ResetAndDestroy() will call for every array element the destructor of the pointed-to object,

    // before deleting the element itself, and closing the array.

    iConfigs.ResetAndDestroy();

    __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::~DUsbClientController(): Done."));

    }

EXPORT_C DUsbClientController* DUsbClientController::Create(UsbShai::MPeripheralControllerIf&               aPeripheralControllerIf, 

                                                            const UsbShai::TPeripheralControllerProperties& aProperties,

                                                            TBool                                  aIsOtgPort)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::Create"));

        // Attempt to create the object

    DUsbClientController* usbcc = new DUsbClientController(aPeripheralControllerIf, 

                                                           aProperties,

                                                           aIsOtgPort);

    __ASSERT_DEBUG( (usbcc != NULL), Kern::Fault( "  USB PSL Out of memory, DUsbClientController", __LINE__ ) );

    if (usbcc != NULL)

        {

        // Second phase constructor

        TInt err = usbcc->Construct();

        __ASSERT_DEBUG( (err == KErrNone), Kern::Fault( "DUsbClientController::Construct failed", err) );

        if (err != KErrNone)

            {

            delete usbcc;

            usbcc = NULL;

            }

        }

    __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::Create instance = %d",usbcc));

    return usbcc;

    }

/**

 * FIXME: This function used to be called by the dummy DCD to disable

 * the peripheral stack. It has been deprecated and we currently use

 * DisablePeripheralStack() to achieve the same effect.

 */

EXPORT_C void DUsbClientController::DisableClientStack()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("CALL TO OBSOLETE FUNCTION: DUsbClientController::DisableClientStack()"));

    }

/**

 * FIXME: This function used to be called by the dummy DCD to enable

 * the peripheral stack. It has been deprecated and we currently use

 * EnablePeripheralStack() to achieve the same effect.

 */

EXPORT_C void DUsbClientController::EnableClientStack()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("CALL TO OBSOLETE FUNCTION: DUsbClientController::EnableClientStack()"));

    }

/** Called by LDD to see if controller is usable.

    @return ETrue if controller is in normal state, EFalse if it is disabled.

*/

EXPORT_C TBool DUsbClientController::IsActive()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::IsActive = %d",iStackIsActive));

    return iStackIsActive;

    }

/** Called by LDD to register client callbacks.

    @return KErrNone if successful, KErrAlreadyExists callback exists.

*/

EXPORT_C TInt DUsbClientController::RegisterClientCallback(TUsbcClientCallback& aCallback)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::RegisterClientCallback()"));

    if (iClientCallbacks.Elements() == KUsbcMaxListLength)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Maximum list length reached: %d",

                                          KUsbcMaxListLength));

        return KErrGeneral;

        }

    TSglQueIter<TUsbcClientCallback> iter(iClientCallbacks);

    TUsbcClientCallback* p;

    while ((p = iter++) != NULL)

        if (p == &aCallback)

            {

            __KTRACE_OPT(KUSB, Kern::Printf("     Error: ClientCallback @ 0x%x already registered", &aCallback));

            return KErrAlreadyExists;

            }

    iClientCallbacks.AddLast(aCallback);

    __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::RegisterClientCallback()"));

    return KErrNone;

    }

/** Returns a pointer to the USB client controller object.

    This function is static.

    @param aUdc The number of the UDC (0..n) for which the pointer is to be returned.

    @return A pointer to the USB client controller object.

*/

EXPORT_C DUsbClientController* DUsbClientController::UsbcControllerPointer(TInt aUdc)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::UsbcControllerPointer()"));

    if (aUdc < 0 || aUdc > 1)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: aUdc out of range (%d)", aUdc));

        return NULL;

        }

    __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::UsbcControllerPointer()"));

    return UsbClientController[aUdc];

    }

/** Fills the buffer passed in as an argument with endpoint capability information.

     @see DUsbClientController::DeviceCaps()

    @see TUsbcEndpointData

    @see TUsbDeviceCaps

    @param aClientId A pointer to the LDD making the enquiry.

    @param aCapsBuf A reference to a descriptor buffer, which, on return, contains an array of

    TUsbcEndpointData elements; there are TUsbDeviceCaps::iTotalEndpoints elements in the array;

    call DeviceCaps() to get the number of elements required.

*/

EXPORT_C void DUsbClientController::EndpointCaps(const DBase* aClientId, TDes8& aCapsBuf) const

    {

    __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::EndpointCaps()"));

    // Here we do not simply call DUsbClientController::DeviceEndpointCaps(),

    // because that function fills an array which comprises of _all_ endpoints,

    // whereas this function omits ep0 and all unusable endpoints.

    // Apart from that, we have to fill an array of TUsbcEndpointData, not TUsbcEndpointCaps.

    TUsbcEndpointData data[KUsbcMaxEndpoints];

    const TInt ifcset_num = ClientId2InterfaceNumber(aClientId);

    for (TInt i = 2, j = 0; i < iDeviceTotalEndpoints; ++i)

        {

        __KTRACE_OPT(KUSB, Kern::Printf("  DUsbClientController::Caps: RealEndpoint #%d", i));

        if (iRealEndpoints[i].iCaps.iTypesAndDir != UsbShai::KUsbEpNotAvailable)

            {

            __KTRACE_OPT(KUSB, Kern::Printf("  DUsbClientController::Caps: --> UsableEndpoint #%d", j));

            data[j].iCaps.iSizes = iRealEndpoints[i].iCaps.iSizes;

            data[j].iCaps.iTypesAndDir = iRealEndpoints[i].iCaps.iTypesAndDir;

            data[j].iCaps.iHighBandwidth = iRealEndpoints[i].iCaps.iHighBandwidth;

            data[j].iCaps.iReserved[0] = iRealEndpoints[i].iCaps.iReserved[0];

            data[j].iCaps.iReserved[1] = iRealEndpoints[i].iCaps.iReserved[1];

            if (ifcset_num < 0)

                {

                // If this LDD doesn't own an interface, but the Ep points to one,

                // then that must be the interface of a different LDD. Hence the Ep

                // is not available for this LDD.

                data[j].iInUse = (iRealEndpoints[i].iIfcNumber != NULL);

                }

            else

                {

                // If this LDD does already own an interface, and the Ep also points to one,

                // then the Ep is not available for this LDD only if that interface is owned

                // by a different LDD (i.e. if the interface number is different).

                // Reason: Even though the endpoint might already be part of an interface setting,

                // it is still available for a different alternate setting of the same interface.

                data[j].iInUse = ((iRealEndpoints[i].iIfcNumber != NULL) &&

                                  (*(iRealEndpoints[i].iIfcNumber) != ifcset_num));

                }

            j++;

            }

        }

    // aCapsBuf resides in userland

    TPtrC8 des((TUint8*)data, sizeof(data));

    const TInt r = Kern::ThreadDesWrite((reinterpret_cast<const DLddUsbcChannel*>(aClientId))->Client(),

                                        &aCapsBuf, des, 0, KChunkShiftBy0, NULL);

    if (r != KErrNone)

        {

        Kern::ThreadKill((reinterpret_cast<const DLddUsbcChannel*>(aClientId))->Client(),

                         EExitPanic, r, KUsbPILKillCat);

        }

    __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::EndpointCaps()"));

    }

/** Fills the buffer passed in as an argument with device capability information.

    @see TUsbDeviceCaps

    @see TUsbDeviceCapsV01

    @param aClientId A pointer to the LDD making the enquiry.

    @param aCapsBuf A reference to a descriptor buffer which, on return, contains

    a TUsbDeviceCaps structure.

*/

EXPORT_C void DUsbClientController::DeviceCaps(const DBase* aClientId, TDes8& aCapsBuf) const

    {

    __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::DeviceCaps()"));

    TUsbDeviceCaps caps;

    caps().iTotalEndpoints = iDeviceUsableEndpoints;        // not DeviceTotalEndpoints()!

    caps().iSelfPowered = iSelfPowered;

    caps().iRemoteWakeup = iRemoteWakeup;

    caps().iHighSpeed = (iControllerProperties.iControllerCaps & UsbShai::KDevCapHighSpeed)?ETrue:EFalse;

    // PIL always assume controller support this caps, see explaination in peripheral shai header

    caps().iFeatureWord1 = caps().iFeatureWord1 | KUsbDevCapsFeatureWord1_CableDetectWithoutPower;

    caps().iFeatureWord1 = caps().iFeatureWord1 | KUsbDevCapsFeatureWord1_EndpointResourceAllocV2;

    caps().iReserved = 0;

    // aCapsBuf resides in userland

    const TInt r = Kern::ThreadDesWrite((reinterpret_cast<const DLddUsbcChannel*>(aClientId))->Client(),

                                        &aCapsBuf, caps, 0, KChunkShiftBy0, NULL);

    if (r != KErrNone)

        {

        Kern::ThreadKill((reinterpret_cast<const DLddUsbcChannel*>(aClientId))->Client(),

                         EExitPanic, r, KUsbPILKillCat);

        }

    __KTRACE_OPT(KUSB, Kern::Printf("< DUsbClientController::DeviceCaps()"));

    }

TUsbcEndpointInfoArray::TUsbcEndpointInfoArray(const TUsbcEndpointInfo* aData, TInt aDataSize)

    {

    iType = EUsbcEndpointInfo;

    iData = (TUint8*) aData;

    if (aDataSize > 0)

        iDataSize = aDataSize;

    else

        iDataSize = sizeof(TUsbcEndpointInfo);

    }

inline TUsbcEndpointInfo& TUsbcEndpointInfoArray::operator[](TInt aIndex) const

    {

    return *(TUsbcEndpointInfo*) &iData[aIndex * iDataSize];

    }

EXPORT_C TInt DUsbClientController::SetInterface(const DBase* aClientId, DThread* aThread,

                                                 TInt aInterfaceNum, TUsbcClassInfo& aClass,

                                                 TDesC8* aString, TInt aTotalEndpointsUsed,

                                                 const TUsbcEndpointInfo aEndpointData[],

                                                 TInt (*aRealEpNumbers)[6], TUint32 aFeatureWord)

    {

    TUsbcEndpointInfoArray endpointData = TUsbcEndpointInfoArray(aEndpointData);

    return SetInterface(aClientId, aThread, aInterfaceNum, aClass, aString, aTotalEndpointsUsed,

                        endpointData, (TInt*) aRealEpNumbers, aFeatureWord);

    }

/** Creates a new USB interface (one setting), complete with endpoints, descriptors, etc.,

    and chains it into the internal device configuration tree.

    @param aClientId A pointer to the LDD owning the new interface.

    @param aThread A pointer to the thread the owning LDD is running in.

    @param aInterfaceNum The interface setting number of the new interface setting. This must be 0

    if it is the first setting of the interface that gets created, or 1 more than the last setting

    that was created for this interface.

    @param aClass Contains information about the device class this interface might belong to.

    @param aString A pointer to a string that is used for the string descriptor of this interface.

    @param aTotalEndpointsUsed The number of endpoints used by this interface (and also the number of

    elements of the following array).

    @param aEndpointData An array with aTotalEndpointsUsed elements, containing information about the

    endpoints of this interface.

    @return KErrNotSupported if Control endpoints are requested by the LDD but aren't supported by the PIL,

    KErrInUse if at least one requested endpoint is - temporarily or permanently - not available for use,

    KErrNoMemory if (endpoint, interface, string) descriptor allocation fails, KErrGeneral if something else

    goes wrong during endpoint or interface or descriptor creation, KErrNone if interface successfully set up.

*/

EXPORT_C TInt DUsbClientController::SetInterface(const DBase* aClientId, DThread* aThread,

                                                 TInt aInterfaceNum, TUsbcClassInfo& aClass,

                                                 TDesC8* aString, TInt aTotalEndpointsUsed,

                                                 const TUsbcEndpointInfoArray aEndpointData,

                                                 TInt aRealEpNumbers[], TUint32 aFeatureWord)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::SetInterface()"));

    if (aInterfaceNum != 0)

        {

        __KTRACE_OPT(KUSB, Kern::Printf("  alternate interface setting request: #%d", aInterfaceNum));

        }

#ifndef USB_SUPPORTS_CONTROLENDPOINTS

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

        {

        if (aEndpointData[i].iType == UsbShai::KUsbEpTypeControl)

            {

            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: control endpoints not supported"));

            return KErrNotSupported;

            }

        }

#endif

    // Check for endpoint availability & check those endpoint's capabilities

    const TInt ifcset_num = ClientId2InterfaceNumber(aClientId);

    // The passed-in ifcset_num may be -1 now, but that's intended.

    if (!CheckEpAvailability(aTotalEndpointsUsed, aEndpointData, ifcset_num))

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: endpoints not (all) available"));

        return KErrInUse;

        }

    // Create & setup new interface

    TUsbcInterface* ifc = CreateInterface(aClientId, aInterfaceNum, aFeatureWord);

    if (ifc == NULL)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: ifc == NULL"));

        return KErrGeneral;

        }

    // Create logical endpoints

    TInt r = CreateEndpoints(ifc, aTotalEndpointsUsed, aEndpointData, aRealEpNumbers);

    if (r != KErrNone)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: CreateEndpoints() err = %d ",r));

        DeleteInterface(ifc->iInterfaceSet->iInterfaceNumber, aInterfaceNum);

        return r;

        }

    // Create & setup interface, string, and endpoint descriptors

    r = SetupIfcDescriptor(ifc, aClass, aThread, aString, aEndpointData);

    if (r != KErrNone)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: SetupIfcDescriptor() err = %d",r));

        return r;

        }

    __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::SetInterface()"));

    return KErrNone;

    }

/** Releases an existing USB interface (one setting), complete with endpoints, descriptors, etc.,

    and removes it from the internal device configuration tree.

    @param aClientId A pointer to the LDD owning the interface.

    @param aInterfaceNum The setting number of the interface setting to be deleted. This must be

    the highest numbered (or 'last') setting for this interface.

    @return KErrNotFound if interface (not setting) for some reason cannot be found, KErrArgument if an

    invalid interface setting number is specified (not existing or existing but too small), KErrNone if

    interface successfully released or if this client doesn't own any interface.

*/

EXPORT_C TInt DUsbClientController::ReleaseInterface(const DBase* aClientId, TInt aInterfaceNum)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("> DUsbClientController::ReleaseInterface(..., %d)", aInterfaceNum));

    const TInt ifcset = ClientId2InterfaceNumber(aClientId);

    if (ifcset < 0)

        {

        __KTRACE_OPT(KUSB, Kern::Printf("  interface not found")); // no error

        return KErrNone;

        }

    TUsbcInterfaceSet* const ifcset_ptr = InterfaceNumber2InterfacePointer(ifcset);

    if (!ifcset_ptr)

        {

        __KTRACE_OPT(KUSB, Kern::Printf("  Error: interface number %d doesn't exist", ifcset));

        return KErrNotFound;