// 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/chapter9.cpp

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

// Processing of USB spec chapter 9 standard requests.

// 

//

/**

 @file chapter9.cpp

 @internalTechnology

*/

#include <usb/usbc.h>

#include "controltransfersm.h"

//#define ENABLE_EXCESSIVE_DEBUG_OUTPUT

//

// === USB Controller member function implementation - PSL API (protected) ========================

//

/** Used to synchronize the Ep0 state machine between the PSL and PIL.

    Accepts a SETUP packet and returns the next Ep0 state.

    @param aSetupBuf The SETUP packet just received by the PSL.

    @return The next Ep0 state.

    @publishedPartner @released

*/

UsbShai::TControlStage DUsbClientController::EnquireEp0NextStage(const TUint8* aSetupBuf) const

    {

    __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::EnquireEp0NextState()"));

    // This function may be called by the PSL from within an ISR -- so we have

    // to take care what we do here (and also in all functions that get called

    // from here).

    if (SWAP_BYTES_16((reinterpret_cast<const TUint16*>(aSetupBuf)[3])) == 0) // iLength

        {

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

        return UsbShai::EControlTransferStageStatusIn;                            // No-data Control => Status_IN

        }

    else if ((aSetupBuf[0] & KUsbRequestType_DirMask) == KUsbRequestType_DirToDev)

        {

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

        return UsbShai::EControlTransferStageDataOut;                            // Control Write => Data_OUT

        }

    else

        {

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

        return UsbShai::EControlTransferStageDataIn;                                // Control Read => Data_IN

        }

    }

//

// About iLastError.

// This member is used to remember the last error happend during a

// processXXX likewise function.

//

// Before entry of each ProcessXXX, iLastError will be cleared to KErrNone.

//

// --- The USB Spec Chapter 9 Standard Endpoint Zero Device Requests ---

// Record error happend with iLastError, the value already been set to zero

// before entering ProcessSetupPacket call.

void DUsbClientController::ProcessGetDeviceStatus(const TUsbcSetup& aPacket)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::ProcessGetDeviceStatus()"));

    if ( iDeviceState < UsbShai::EUsbPeripheralStateAddress)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Invalid device state"));

        iLastError = KErrGeneral;

        }

    else

        {

        // We always assume Device is bus-powered, even though mobile phone almost always

        // has a battry there, because self-powered device can not required more then 100ma current

        // which is not acceptable for Usb charging.

        TBool selfPowered = EFalse;         

        /*  FIXME: modify selfPowered to make it compilance with following rule.

             1. If current draw exceeds 100mA, the device must report itself 

                as bus-powered during enumeration.

             2. In all cases, the GetStatus(DEVICE) call must accurately report 

                whether the device is currently operating on self- or bus-power.

             3. A device that is actively drawing more than 100mA from USB must 

                report itself as bus-powered in the GetStatus(DEVICE) call.

             4. Peripherals that return "Self-powered" in the GetStatus(DEVICE) 

                call are prohibited from drawing more than 100mA at any time.

        */

        /*   

        TBuf8<KUsbDescSize_Config> config;

        if(iDescriptors.GetConfigurationDescriptorTC(&Kern::CurrentThread(),config) == KErrNone)

            {

            TUint8 maxPower = config[8];

            if(maxPower <= 50)

                {

                selfPowered = EFalse;

                }

            }

        */

        const TUint16 status = ((selfPowered ? KUsbDevStat_SelfPowered : 0) |

                        (iRmWakeupStatus_Enabled ? KUsbDevStat_RemoteWakeup : 0));

        __KTRACE_OPT(KUSB, Kern::Printf("  Reporting device status: 0x%02x", status));

        *reinterpret_cast<TUint16*>(iEp0_TxBuf) = SWAP_BYTES_16(status);

        if (iConTransferMgr->SetupEndpointZeroWrite(iEp0_TxBuf, sizeof(status)) == KErrNone)

            {

            iEp0WritePending = ETrue;

            }

        else

            {

            __KTRACE_OPT(KUSB, Kern::Printf("  Wrong: Write to Ep0 Failed"));

            }

        }

    }

void DUsbClientController::ProcessGetInterfaceStatus(const TUsbcSetup& aPacket)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::ProcessGetInterfaceStatus()"));

    if ( iDeviceState < UsbShai::EUsbPeripheralStateConfigured)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Invalid device state"));

        iLastError = KErrGeneral;

        }

    else

        {

        if (InterfaceExists(aPacket.iIndex) == EFalse)

            {

            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Interface does not exist"));

            iLastError = KErrGeneral;

            }

        else

            {        

            const TUint16 status = 0x0000;                            // as of USB Spec 2.0

            __KTRACE_OPT(KUSB, Kern::Printf("  Reporting interface status: 0x%02x", status));

            *reinterpret_cast<TUint16*>(iEp0_TxBuf) = SWAP_BYTES_16(status);

            if (iConTransferMgr->SetupEndpointZeroWrite(iEp0_TxBuf, sizeof(status)) == KErrNone)

                {

                iEp0WritePending = ETrue;

                }

            else

                {

                __KTRACE_OPT(KUSB, Kern::Printf("  Wrong: Write to Ep0 Failed"));

                }

            }

        }

    }

void DUsbClientController::ProcessGetEndpointStatus(const TUsbcSetup& aPacket)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::ProcessGetEndpointStatus()"));

    if (

        ((iDeviceState < UsbShai::EUsbPeripheralStateAddress) ||

         (iDeviceState == UsbShai::EUsbPeripheralStateAddress && (aPacket.iIndex & KUsbEpAddress_Portmask) != 0)))

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Invalid device state"));

        iLastError = KErrGeneral;

        }

    else

        {

        if (EndpointExists(aPacket.iIndex) == EFalse)

            {

            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Endpoint does not exist"));

            iLastError = KErrGeneral;

            }

        else

            {

            const TInt ep = EpAddr2Idx(aPacket.iIndex);

            const TUint16 status = (iRealEndpoints[ep].iHalt) ?     KUsbEpStat_Halt : 0;

            __KTRACE_OPT(KUSB, Kern::Printf("  Reporting endpoint status 0x%02x for real endpoint %d",

                                            status, ep));

            *reinterpret_cast<TUint16*>(iEp0_TxBuf) = SWAP_BYTES_16(status);

            if (iConTransferMgr->SetupEndpointZeroWrite(iEp0_TxBuf, 2) == KErrNone)

                {

                iEp0WritePending = ETrue;

                }

            else

                {

                __KTRACE_OPT(KUSB, Kern::Printf("  Wrong: Write to Ep0 Failed"));

                }

            }

        }

    }

void DUsbClientController::ProcessSetClearDevFeature(const TUsbcSetup& aPacket)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::ProcessSetClearDevFeature()"));

    if ( iDeviceState < UsbShai::EUsbPeripheralStateDefault)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Invalid device state"));

        iLastError = KErrGeneral;

        return;

        }

    TInt test_sel = 0;

    if (aPacket.iRequest == KUsbRequest_SetFeature)

        {

        switch (aPacket.iValue)

            {

            case KUsbFeature_RemoteWakeup:

                if ( iDeviceState < UsbShai::EUsbPeripheralStateAddress)

                    {

                    __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Invalid device state"));

                    iLastError = KErrGeneral;                

                    }

                else

                    {

                    iRmWakeupStatus_Enabled = ETrue;

                    }

                break;

            case KUsbFeature_TestMode:

                if (!iHighSpeed)

                    {

                    __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Request only supported in High-Speed mode"));

                    iLastError = KErrGeneral;

                    }

                else if (LowByte(aPacket.iIndex) != 0)

                    {

                    __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Lower byte of wIndex must be zero"));

                    iLastError = KErrGeneral;

                    }

                else

                    {

                    test_sel = HighByte(aPacket.iIndex);

                    if ((test_sel < UsbShai::EUsbTestSelector_Test_J) || (test_sel > UsbShai::EUsbTestSelector_Test_Force_Enable))

                        {

                        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Invalid test selector: %d", test_sel));

                        iLastError = KErrGeneral;

                        }

                    }

                break;

            case KUsbFeature_B_HnpEnable:

                if (!iOtgSupport)

                    {

                    __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Request only supported on a OTG device"));

                    iLastError = KErrGeneral;

                    }            

                else if (!(iOtgFuncMap & KUsbOtgAttr_HnpSupp))

                    {

                    __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Request only valid if OTG device supports HNP"));

                    iLastError = KErrGeneral;

                    }

                else

                    {

                    iOtgFuncMap |= KUsbOtgAttr_B_HnpEnable;

                    OtgFeaturesNotify();

                    }

                break;

            case KUsbFeature_A_HnpSupport:

                if (!iOtgSupport)

                    {

                    __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Request only supported on a OTG device"));

                    iLastError = KErrGeneral;

                    }

                else if (!(iOtgFuncMap & KUsbOtgAttr_HnpSupp))

                    {

                    __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Request only valid if OTG device supports HNP"));

                    iLastError = KErrGeneral;

                    }

                else

                    {

                    iOtgFuncMap |= KUsbOtgAttr_A_HnpSupport;

                    OtgFeaturesNotify();

                    }

                break;

            case KUsbFeature_A_AltHnpSupport:

                if (!iOtgSupport)

                    {

                    __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Request only supported on a OTG device"));

                    iLastError = KErrGeneral;

                    }

                else if (!(iOtgFuncMap & KUsbOtgAttr_HnpSupp))

                    {

                    __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Request only valid if OTG device supports HNP"));

                    iLastError = KErrGeneral;

                    }

                else

                    {

                    iOtgFuncMap |= KUsbOtgAttr_A_AltHnpSupport;

                    OtgFeaturesNotify();

                    }

                break;

            default:

                __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Unknown feature requested"));

                iLastError = KErrGeneral;                

            }

        }

    else // KUsbRequest_ClearFeature

        {

        switch (aPacket.iValue)

            {

            case KUsbFeature_RemoteWakeup:

                if ( iDeviceState < UsbShai::EUsbPeripheralStateAddress)

                    {

                    __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Invalid device state"));

                    iLastError = KErrGeneral;

                    }

                else

                    {

                    iRmWakeupStatus_Enabled = EFalse;

                    }

                break;

            default:

                __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Unknown feature requested"));

                iLastError = KErrGeneral;

            }

        }

    if(iLastError == KErrNone)

        {

        // Sent out status packet if no error found.

        iConTransferMgr->SendEp0ZeroByteStatusPacket();                            // success: zero bytes data during status stage

        // 9.4.9: "The transition to test mode of an upstream facing port must not happen until

        // after the status stage of the request."

        if (test_sel)

            {

            __KTRACE_OPT(KPANIC, Kern::Printf("  Entering HS Test Mode %d", test_sel));

            iController.EnterTestMode((UsbShai::TUsbTestModeSelector)test_sel);

            }

        }

    }

void DUsbClientController::ProcessSetClearIfcFeature(const TUsbcSetup& aPacket)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::ProcessSetClearIfcFeature()"));

    if ( iDeviceState < UsbShai::EUsbPeripheralStateConfigured)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Invalid device state"));

        iLastError = KErrGeneral;

        }

    else

        {

        // No interface features defined in USB spec, thus

        iLastError = KErrGeneral;

        }

    }

void DUsbClientController::ProcessSetClearEpFeature(const TUsbcSetup& aPacket)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::ProcessSetClearEpFeature()"));

    if (

        ((iDeviceState < UsbShai::EUsbPeripheralStateAddress) ||

         (iDeviceState == UsbShai::EUsbPeripheralStateAddress && (aPacket.iIndex & KUsbEpAddress_Portmask) != 0)))

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Invalid device state"));

        iLastError = KErrGeneral;

        }

    else if (aPacket.iValue != KUsbFeature_EndpointHalt)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Unknown feature requested"));

        iLastError = KErrGeneral;

        }

    else if (EndpointExists(aPacket.iIndex) == EFalse)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Endpoint does not exist"));

        iLastError = KErrGeneral;

        }

    else

        {

        const TInt ep = EpAddr2Idx(aPacket.iIndex);

        if (iRealEndpoints[ep].iLEndpoint->iInfo.iType == UsbShai::KUsbEpTypeControl ||

            iRealEndpoints[ep].iLEndpoint->iInfo.iType == UsbShai::KUsbEpTypeIsochronous)

            {

            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Endpoint is Control or Isochronous"));

            iLastError = KErrGeneral;

            }

        else

            {

            SetClearHaltFeature(ep, aPacket.iRequest);

            // success: zero bytes data during status stage

            iConTransferMgr->SendEp0ZeroByteStatusPacket();

            }

        }

    }

void DUsbClientController::ProcessSetAddress(const TUsbcSetup& aPacket)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::ProcessSetAddress()"));

    if ( iDeviceState > UsbShai::EUsbPeripheralStateAddress)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Invalid device state"));

        iLastError = KErrGeneral;

        }

    else

        {

        const TUint16 addr = aPacket.iValue;

        if (addr > 127)

            {

            __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Bad address value: %d (>127)", addr));

            iLastError = KErrGeneral;

            }

        else if (addr == 0)

            {

            // Enter Default state (from Default or Address)

            NextDeviceState(UsbShai::EUsbPeripheralStateDefault);

            }

        __KTRACE_OPT(KUSB, Kern::Printf("  USB address: %d", addr));

        // If controller support hw acceleration,call set address first and then status

        if(iControllerProperties.iControllerCaps & UsbShai::KDevCapSetAddressAcceleration)

            {

            iController.SetDeviceAddress(addr);

            }

        // The spec says, under section 9.4.6:

        // "Stages after the initial Setup packet assume the same device address as the Setup packet. The USB

        // device does not change its device address until after the Status stage of this request is completed

        // successfully. Note that this is a difference between this request and all other requests. For all other

        // requests, the operation indicated must be completed before the Status stage."

        // Therefore, here we first send the status packet and only then actually execute the request.

        iConTransferMgr->SendEp0ZeroByteStatusPacket();

        // If controller doesn't support hw acceleration, call set address after status

        if((iControllerProperties.iControllerCaps & UsbShai::KDevCapSetAddressAcceleration) == 0)

            {

            iController.SetDeviceAddress(addr);

            }

        }

    }

void DUsbClientController::ProcessGetDescriptor(const TUsbcSetup& aPacket)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::ProcessGetDescriptor()"));

    if ( iDeviceState < UsbShai::EUsbPeripheralStateDefault)

        {

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Invalid device state"));

        iLastError = KErrGeneral;

        return ;

        }

    // Make sure we assume the correct speed

    __ASSERT_DEBUG((iHighSpeed == CurrentlyUsingHighSpeed()), Kern::Fault(KUsbPILPanicCat, __LINE__));

    TInt size = 0;

    const TInt result = iDescriptors.FindDescriptor(HighByte(aPacket.iValue), // Type

                                                    LowByte(aPacket.iValue), // Index

                                                    aPacket.iIndex, // Language ID

                                                    size);

    if ((result != KErrNone) || (size == 0))

        {

        // This doesn't have to be an error - protocol-wise it's OK.

        __KTRACE_OPT(KUSB, Kern::Printf("  Couldn't retrieve descriptor"));

        iLastError = KErrGeneral;

        return;

        }

    __KTRACE_OPT(KUSB, Kern::Printf("  Descriptor found, size: %d (requested: %d)",

                                    size, aPacket.iLength));

    if (size > KUsbcBufSz_Ep0Tx)

        {

        // This should actually not be possible (i.e. we should never get here).

        __KTRACE_OPT(KPANIC, Kern::Printf("  Error: Ep0_Tx buffer too small"));

        }

    if (size > aPacket.iLength)

        {

        // Send only as much data as requested by the host

        size = aPacket.iLength;

        }

#ifdef ENABLE_EXCESSIVE_DEBUG_OUTPUT

    __KTRACE_OPT(KUSB,

                 Kern::Printf("  Data: 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x ...",

                              iEp0_TxBuf[0], iEp0_TxBuf[1], iEp0_TxBuf[2], iEp0_TxBuf[3],

                              iEp0_TxBuf[4], iEp0_TxBuf[5], iEp0_TxBuf[6], iEp0_TxBuf[7]));

#endif

    // If we're about to send less bytes than expected by the host AND our number is a

    // multiple of the packet size, in order to indicate the end of the control transfer,

    // we must finally send a zero length data packet (ZLP):

    const TBool zlp = ((size < aPacket.iLength) && (size % iEp0MaxPacketSize == 0));

    if (iConTransferMgr->SetupEndpointZeroWrite(iEp0_TxBuf, size, zlp) == KErrNone)

        {

        iEp0WritePending = ETrue;

        }

    else

        {

        __KTRACE_OPT(KUSB, Kern::Printf("  Wrong: Write to Ep0 Failed"));

        }

    }

void DUsbClientController::ProcessSetDescriptor(const TUsbcSetup& aPacket)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::ProcessSetDescriptor()"));

#ifndef USB_SUPPORTS_SET_DESCRIPTOR_REQUEST

    iLastError = KErrGeneral;

    return;

#else

    if ( iDeviceState < UsbShai::EUsbPeripheralStateAddress)

        {

        // Error: Invalid device state!

        iLastError = KErrGeneral;

        }