/**

 @file misc.cpp

 @internalTechnology

*/

// #include <drivers/usbc.h>

#include <usb/usbc.h>

/** Helper function for logical endpoints and endpoint descriptors:

    Split single Ep size into separate FS/HS sizes.

    This function modifies its arguments.

 */

TInt TUsbcEndpointInfo::AdjustEpSizes(TInt& aEpSize_Fs, TInt& aEpSize_Hs) const

    {

    if (iType == UsbShai::KUsbEpTypeBulk)

        {

        // FS: [8|16|32|64] HS: 512

        if (iSize < 64)

            {

            aEpSize_Fs = iSize;

            }

        else

            {

            aEpSize_Fs = 64;

            }

        aEpSize_Hs = 512;

        }

    else if (iType == UsbShai::KUsbEpTypeInterrupt)

        {

        // FS: [0..64] HS: [0..1024]

        if (iSize < 64)

            {

            aEpSize_Fs = iSize;

            }

        else

            {

            aEpSize_Fs = 64;

            }

        aEpSize_Hs = iSize;

        }

    else if (iType == UsbShai::KUsbEpTypeIsochronous)

        {

        // FS: [0..1023] HS: [0..1024]

        if (iSize < 1023)

            {

            aEpSize_Fs = iSize;

            }

        else

            {

            aEpSize_Fs = 1023;

            }

        aEpSize_Hs = iSize;

        }

    else if (iType == UsbShai::KUsbEpTypeControl)

        {

        // FS: [8|16|32|64] HS: 64

        if (iSize < 64)

            {

            aEpSize_Fs = iSize;

            }

        else

            {

            aEpSize_Fs = 64;

            }

        aEpSize_Hs = 64;

        }

    else

        {

        aEpSize_Fs = aEpSize_Hs = 0;

        return KErrGeneral;

        }

    // For the reason of the following checks see Table 9-14. "Allowed wMaxPacketSize

    // Values for Different Numbers of Transactions per Microframe".

    if ((iType == UsbShai::KUsbEpTypeInterrupt) || (iType == UsbShai::KUsbEpTypeIsochronous))

        {

        if (iTransactions == 1)

            {

            if (aEpSize_Hs < 513)

                {

                __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: Ep size too small: %d < 513. Correcting...",

                                                  aEpSize_Hs));

                aEpSize_Hs = 513;

                }

            }

        else if (iTransactions == 2)

            {

            if (aEpSize_Hs < 683)

                {

                __KTRACE_OPT(KPANIC, Kern::Printf("  Warning: Ep size too small: %d < 683. Correcting...",

                                                  aEpSize_Hs));

                aEpSize_Hs = 683;

                }

            }

        }

    return KErrNone;

    }

/** Helper function for logical endpoints and endpoint descriptors:

    If not set, assign a valid and meaningful value to iInterval_Hs, deriving from iInterval.

    This function modifies the objects's data member(s).

 */

TInt TUsbcEndpointInfo::AdjustPollInterval()

    {

    if (iInterval_Hs != -1)

        {

        // Already done.

        return KErrNone;

        }

    if ((iType == UsbShai::KUsbEpTypeBulk) || (iType == UsbShai::KUsbEpTypeControl))

        {

        // Valid range: 0..255 (maximum NAK rate).

        // (The host controller will probably ignore this value though -

        //  see the last sentence of section 9.6.6 for details.)

        iInterval_Hs = 255;

        }

    else if (iType == UsbShai::KUsbEpTypeInterrupt)

        {

        // HS interval = 2^(iInterval_Hs-1) with a valid iInterval_Hs range of 1..16.

        // The following table shows the mapping of HS values to actual intervals (and

        // thus FS values) for the range of possible FS values (1..255).

        // There is not always a 1:1 mapping possible, but we want at least to make sure

        // that the HS polling interval is never longer than the FS one (except for 255).

        //

        // 1 = 1

        // 2 = 2

        // 3 = 4

        // 4 = 8

        // 5 = 16

        // 6 = 32

        // 7 = 64

        // 8 = 128

        // 9 = 256

        if (iInterval == 255)

            iInterval_Hs = 9;

        else if (iInterval >= 128)

            iInterval_Hs = 8;

        else if (iInterval >= 64)

            iInterval_Hs = 7;

        else if (iInterval >= 32)

            iInterval_Hs = 6;

        else if (iInterval >= 16)

            iInterval_Hs = 5;

        else if (iInterval >= 8)

            iInterval_Hs = 4;

        else if (iInterval >= 4)

            iInterval_Hs = 3;

        else if (iInterval >= 2)

            iInterval_Hs = 2;

        else if (iInterval == 1)

            iInterval_Hs = 1;

        else

            {

            // iInterval wasn't set properly by the user

            iInterval_Hs = 1;

            return KErrGeneral;

            }

        }

    else if (iType == UsbShai::KUsbEpTypeIsochronous)

        {

        // Interpretation is the same for FS and HS.

        iInterval_Hs = iInterval;

        }

    else

        {

        // '1' is a valid value for all endpoint types...

        iInterval_Hs = 1;

        return KErrGeneral;

        }

    return KErrNone;

    }

TUsbcPhysicalEndpoint::TUsbcPhysicalEndpoint()

    : iEndpointAddr(0), iIfcNumber(NULL), iLEndpoint(NULL), iSettingReserve(EFalse), iHalt(EFalse)

    {

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

    }

TInt TUsbcPhysicalEndpoint::TypeAvailable(TUint aType) const

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcPhysicalEndpoint::TypeAvailable"));

    switch (aType)

        {

    case UsbShai::KUsbEpTypeControl:

        return (iCaps.iTypesAndDir & UsbShai::KUsbEpTypeControl);

    case UsbShai::KUsbEpTypeIsochronous:

        return (iCaps.iTypesAndDir & UsbShai::KUsbEpTypeIsochronous);

    case UsbShai::KUsbEpTypeBulk:

        return (iCaps.iTypesAndDir & UsbShai::KUsbEpTypeBulk);

    case UsbShai::KUsbEpTypeInterrupt:

        return (iCaps.iTypesAndDir & UsbShai::KUsbEpTypeInterrupt);

    default:

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: invalid EP type: %d", aType));

        return 0;

        }

    }

TInt TUsbcPhysicalEndpoint::DirAvailable(TUint aDir) const

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcPhysicalEndpoint::DirAvailable"));

    switch (aDir)

        {

    case UsbShai::KUsbEpDirIn:

        return (iCaps.iTypesAndDir & UsbShai::KUsbEpDirIn);

    case UsbShai::KUsbEpDirOut:

        return (iCaps.iTypesAndDir & UsbShai::KUsbEpDirOut);

    default:

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: invalid EP direction: %d", aDir));

        return 0;

        }

    }

TInt TUsbcPhysicalEndpoint::EndpointSuitable(const TUsbcEndpointInfo* aEpInfo, TInt aIfcNumber) const

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcPhysicalEndpoint::EndpointSuitable"));

    __KTRACE_OPT(KUSB, Kern::Printf("  looking for EP: type=0x%x dir=0x%x size=%d (ifc_num=%d)",

                                    aEpInfo->iType, aEpInfo->iDir, aEpInfo->iSize, aIfcNumber));

    if (iSettingReserve)

        {

        __KTRACE_OPT(KUSB, Kern::Printf("  -> setting conflict"));

        return 0;

        }

    // (aIfcNumber == -1) means the ep is for a new default interface setting

    else if (iIfcNumber && (*iIfcNumber != aIfcNumber))

        {

        // If this endpoint has already been claimed (iIfcNumber != NULL),

        // but by a different interface(-set) than the currently looking one

        // (*iIfcNumber != aIfcNumber), then it's not available.

        // This works because we can assign the same physical endpoint

        // to different alternate settings of the *same* interface, and

        // because we check for available endpoints for every alternate setting

        // as a whole.

        __KTRACE_OPT(KUSB, Kern::Printf("  -> ifc conflict"));

        return 0;

        }

    else if (!TypeAvailable(aEpInfo->iType))

        {

        __KTRACE_OPT(KUSB, Kern::Printf("  -> type conflict"));

        return 0;

        }

    else if (!DirAvailable(aEpInfo->iDir))

        {

        __KTRACE_OPT(KUSB, Kern::Printf("  -> direction conflict"));

        return 0;

        }

    else if (!(iCaps.iSizes & PacketSize2Mask(aEpInfo->iSize)) && !(iCaps.iSizes & UsbShai::KUsbEpSizeCont))

        {

        __KTRACE_OPT(KUSB, Kern::Printf("  -> size conflict"));

        return 0;

        }

    else

        return 1;

    }

TUsbcPhysicalEndpoint::~TUsbcPhysicalEndpoint()

    {

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

    iLEndpoint = NULL;

    }

TUsbcLogicalEndpoint::TUsbcLogicalEndpoint(DUsbClientController* aController, TUint aEndpointNum,

                                           const TUsbcEndpointInfo& aEpInfo, TUsbcInterface* aInterface,

                                           TUsbcPhysicalEndpoint* aPEndpoint)

    : iController(aController), iLEndpointNum(aEndpointNum), iInfo(aEpInfo), iInterface(aInterface),

      iPEndpoint(aPEndpoint)

    {

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

    //  Adjust FS/HS endpoint sizes

    if (iInfo.AdjustEpSizes(iEpSize_Fs, iEpSize_Hs) != KErrNone)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Unknown endpoint type: %d", iInfo.iType));

        }

    __KTRACE_OPT(KUSB, Kern::Printf("  Now set: iEpSize_Fs=%d iEpSize_Hs=%d (iInfo.iSize=%d)",

                                    iEpSize_Fs, iEpSize_Hs, iInfo.iSize));

    //  Adjust HS polling interval

    if (iInfo.AdjustPollInterval() != KErrNone)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Unknown ep type (%d) or invalid interval value (%d)",

                                          iInfo.iType, iInfo.iInterval));

        }

    __KTRACE_OPT(KUSB, Kern::Printf("  Now set: iInfo.iInterval=%d iInfo.iInterval_Hs=%d",

                                    iInfo.iInterval, iInfo.iInterval_Hs));

    // Additional transactions requested on a non High Bandwidth ep?

    if ((iInfo.iTransactions > 0) && !aPEndpoint->iCaps.iHighBandwidth)

        {

        __KTRACE_OPT(KPANIC,

                     Kern::Printf("  Warning: Additional transactions requested but not a High Bandwidth ep"));

        }

    }

TUsbcLogicalEndpoint::~TUsbcLogicalEndpoint()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcLogicalEndpoint::~TUsbcLogicalEndpoint: #%d", iLEndpointNum));

    // If the real endpoint this endpoint points to is also used by

    // any other logical endpoint in any other setting of this interface

    // then we leave the real endpoint marked as used. Otherwise we mark

    // it as available (set its ifc number pointer to NULL).

    const TInt n = iInterface->iInterfaceSet->iInterfaces.Count();

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

        {

        const TUsbcInterface* const ifc = iInterface->iInterfaceSet->iInterfaces[i];

        const TInt m = ifc->iEndpoints.Count();

        for (TInt j = 0; j < m; ++j)

            {

            const TUsbcLogicalEndpoint* const ep = ifc->iEndpoints[j];

            if ((ep->iPEndpoint == iPEndpoint) && (ep != this))

                {

                __KTRACE_OPT(KUSB, Kern::Printf("  Physical endpoint still in use -> we leave it as is"));

                return;

                }

            }

        }

    __KTRACE_OPT(KUSB, Kern::Printf("  Closing DMA channel"));

    const TInt idx = iController->EpAddr2Idx(iPEndpoint->iEndpointAddr);

    // If the endpoint doesn't support DMA (now or ever) the next operation will be a no-op.

    // iController->CloseDmaChannel(idx);

    __KTRACE_OPT(KUSB, Kern::Printf("  Setting physical ep 0x%02x ifc number to NULL (was %d)",

                                    iPEndpoint->iEndpointAddr, *iPEndpoint->iIfcNumber));

    iPEndpoint->iIfcNumber = NULL;

    }

TUsbcInterface::TUsbcInterface(TUsbcInterfaceSet* aIfcSet, TUint8 aSetting, TBool aNoEp0Requests)

    : iEndpoints(2), iInterfaceSet(aIfcSet), iSettingCode(aSetting), iNoEp0Requests(aNoEp0Requests)

    {

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

    }

TUsbcInterface::~TUsbcInterface()

    {

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

    iEndpoints.ResetAndDestroy();

    }

TUsbcInterfaceSet::TUsbcInterfaceSet(const DBase* aClientId, TUint8 aIfcNum)

    : iInterfaces(2), iClientId(aClientId), iInterfaceNumber(aIfcNum), iCurrentInterface(0)

    {

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

    }

TUsbcInterfaceSet::~TUsbcInterfaceSet()

    {

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

    iInterfaces.ResetAndDestroy();

    }

TUsbcConfiguration::TUsbcConfiguration(TUint8 aConfigVal)

    : iInterfaceSets(1), iConfigValue(aConfigVal)            // iInterfaceSets(1): granularity

    {

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

    }

TUsbcConfiguration::~TUsbcConfiguration()

    {

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

    iInterfaceSets.ResetAndDestroy();

    }

_LIT(KDriverName, "Usbcc");

DUsbcPowerHandler::DUsbcPowerHandler(DUsbClientController* aController)

    : DPowerHandler(KDriverName), iController(aController)

    {}

void DUsbcPowerHandler::PowerUp()

    {

    if (iController)

        iController->iPowerUpDfc.Enque();

    }

void DUsbcPowerHandler::PowerDown(TPowerState)

    {

    if (iController)

        iController->iPowerDownDfc.Enque();

    }

// -eof-