// 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\usbcsc\d_usbcsc.cpp

// LDD for USB Device driver stack, using shared chunks:

// The channel object.

// 

//

/**

 @file d_usbcsc.cpp

 @internalTechnology

*/

// #include <drivers/usbcsc.h>

#include <usb/usbcsc.h>

#include "platform.h"

/*****************************************************************************\

*   DUsbcScLogDevice                                                          *

*                                                                             *

*   Inherits from DLogicalDevice, the USB Shared Chunk LDD factory class      *

*                                                                             *

\*****************************************************************************/

_LIT(KUsbScLddName, "Usbcsc");

static const TInt KUsbRequestCallbackPriority = 2;

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

 */

DECLARE_STANDARD_LDD()

    {

    return new DUsbcScLogDevice;

    }

/** Create a channel on the device.

    @internalComponent

*/

TInt DUsbcScLogDevice::Create(DLogicalChannelBase*& aChannel)

    {

    aChannel = new DLddUsbcScChannel;

    return aChannel ? KErrNone : KErrNoMemory;

    }

DUsbcScLogDevice::DUsbcScLogDevice()

      {

      iParseMask = KDeviceAllowUnit;

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

      iVersion = TVersion(KUsbcScMajorVersion, KUsbcScMinorVersion, KUsbcScBuildVersion);

      }

TInt DUsbcScLogDevice::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(&KUsbScLddName);

    }

//

// Return the USB controller capabilities.

//

void DUsbcScLogDevice::GetCaps(TDes8& aDes) const

    {

    TPckgBuf<TCapsDevUsbc> b;

    b().version = iVersion;

    Kern::InfoCopy(aDes, b);

    }

// End DUsbcScLogDevice

/*****************************************************************************\

*   TUsbcScChunkInfo                                                          *

*                                                                             *

*   Where Chunk information is stored for the channel, and preseved for the   *

*   life of the chunk.                                                        *

*                                                                             *

\*****************************************************************************/

void DfcChunkCleanup(TAny*);

TUsbcScChunkInfo::TUsbcScChunkInfo(DLogicalDevice* aLdd)

    :     iChunk(NULL),

        iCleanup((TDfcFn)&DfcChunkCleanup,this,Kern::SvMsgQue(),0),

        iChunkMem(NULL),

        iLdd(aLdd)

    {

    iPageNtz = (TInt8)__e32_find_ls1_32(Kern::RoundToPageSize(1));

    }

TInt TUsbcScChunkInfo::CreateChunk(TInt aTotalSize)

    {

    // First, reserve an TUint of memory for each of pages needed to hold aTotalSize of memory.

    // This will form the chunk map, so that we can look up the memory geometry.

    iAllocatedSize = (aTotalSize>>iPageNtz)*sizeof(TUint);

    iPhysicalMap = (TUint*) Kern::AllocZ(iAllocatedSize);

    TInt r;

    if (iPhysicalMap==NULL)

        r = KErrNoMemory;

    else

        {

        TChunkCreateInfo chunkInfo;

        chunkInfo.iType = TChunkCreateInfo::ESharedKernelMultiple;

        chunkInfo.iMaxSize = aTotalSize;

        chunkInfo.iMapAttr = EMapAttrCachedMax;

        chunkInfo.iOwnsMemory = EFalse;

        chunkInfo.iDestroyedDfc = &iCleanup;

        TLinAddr chunkMem;

        r = Kern::ChunkCreate(chunkInfo, iChunk, chunkMem, iChunkMapAttr);

        iChunkMem = (TInt8*) chunkMem;

        if (r==KErrNone)

            iLdd->Open();

        }

    return r;

}

// This method requests closing the chunk.

// Note that nothing may happen immediately, as something else may have the chunk open.

void TUsbcScChunkInfo::Close()

{

    Kern::ChunkClose(iChunk);    

}

TInt TUsbcScChunkInfo::ChunkAlloc(TInt aOffset, TInt aSize)

    {

    TUint pageMask = (~0)<<iPageNtz;

    TUint rleMask = ~pageMask;

    TUint pageSize = rleMask+1;

    TInt r;

    TLinAddr physAddr;

    __KTRACE_OPT(KUSB, Kern::Printf("::chunkalloc  AllocPhysicalRam aSize %d", aSize));

    r = Epoc::AllocPhysicalRam(aSize, physAddr);

    __KTRACE_OPT(KUSB, if (r!=KErrNone) Kern::Printf("::chunkalloc AllocPhysicalRam r=%d  (Error!)", r));

    if (r==KErrNone)

        {    

        __KTRACE_OPT(KUSB, Kern::Printf("::chunkalloc ChunkCommitPhysical iChunk 0x%x size(%d), aOffset 0x%x, aSize 0x%x phsAddr 0x%x",

                                                                                     iChunk, sizeof(DChunk), aOffset, aSize,physAddr ));

        r = Kern::ChunkCommitPhysical(iChunk, aOffset, aSize, physAddr);

        __KTRACE_OPT(KUSB, if (r!=KErrNone) Kern::Printf("::chunkalloc ChunkCommitPhysical r=%d  (Error!)", r));

        if (r!=KErrNone)

                Epoc::FreePhysicalRam(physAddr, aSize);

        else 

            { // record physical address and length in physical map

            TInt rle;

            TInt i=0;

            for (rle=(aSize>>iPageNtz); rle>0; rle--, i++,physAddr+=pageSize) 

                {

                __KTRACE_OPT(KUSB, Kern::Printf("::phys offset 0x%x = 0x%x",

                                                (aOffset>>iPageNtz)+i,  (physAddr & pageMask) | ((rle>(TInt)rleMask)?(TInt)rleMask:rle)));

                iPhysicalMap[(aOffset>>iPageNtz)+i] = (physAddr & pageMask) | ((rle>(TInt)rleMask)?(TInt)rleMask:rle);

                }

            }

        }

    else if (r==KErrNoMemory)

        r = -KErrNoMemory;  // Semi-expected error.

    return r;

    }

/**

This method retrieves the physical address of a given offset into the Chunk, and returns

the length of contiguous physical memory from this point.

@param aOffset        the offset from the start of the chunk, to be queried.

@param aPhysical    a pointer to a TPhysAddr, to be filled with the physical

                    address of the memory at the given offset.

@returns the length of contiguous physical memory from the given offset.

*/

TInt TUsbcScChunkInfo::GetPhysical(TInt aOffset, TPhysAddr* aPhysical)

    {

    // Use masks, to retrieve the two components from the physical map, we created of the memory.

    TUint pageMask = (~0)<<iPageNtz;

    TUint val =  iPhysicalMap[aOffset>>iPageNtz];

    *aPhysical=(val & pageMask)+(aOffset & ~pageMask);

    return ((val & ~pageMask)<<iPageNtz) -  (aOffset & ~pageMask);

    }

// DFC calls this fuction, which invokes the cleanup method.

void DfcChunkCleanup(TAny* aChunkInfo)

    {

    ((TUsbcScChunkInfo*) aChunkInfo)->ChunkCleanup();

    }

void TUsbcScChunkInfo::ChunkCleanup()

{

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScChunkInfo::ChunkCleanup()"));

    TUint physAddr;

    TInt length;

    TInt offset = 0;

    // The part of the field used for the physical page address.

    TUint pageMask = (~0)<<iPageNtz;

    // The part of the field used for the run length encoding, of the contiguous pages.

    TUint rleMask = ~pageMask;

    TInt records=(iAllocatedSize>>2);

    while (offset < records) 

        {

        physAddr =     iPhysicalMap[offset] & pageMask;

        length = iPhysicalMap[offset] & rleMask;

        if (physAddr>0)    

            Epoc::FreePhysicalRam(physAddr, length);

        offset += (length>0)?length:1;

        }

    Kern::Free(iPhysicalMap);

    DLogicalDevice* ldd = iLdd;

    delete this;

    ldd->Close(NULL);

}

TInt TUsbcScChunkInfo::New(TUsbcScChunkInfo*& aChunk, TInt aSize, DLogicalDevice* aLdd)

{

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScChunkInfo::New totalSize %d", aSize));

    aChunk = new TUsbcScChunkInfo(aLdd);

    if (aChunk==NULL)

        {

        return KErrNoMemory;

        }

    TInt r = aChunk->CreateChunk(aSize);

    if (r!=KErrNone)

        {

        delete aChunk;

        aChunk=NULL;

        return r;

        }

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScChunkInfo::New Created at 0x%x",  aChunk->iChunkMem  ));

    return KErrNone;

}

// End TUsbcScChunkInfo

/*****************************************************************************\

*    TUsbcScBuffer                                                            *

*                                                                             *

*    Represents a buffer, within a chunk.  Each buffers can be used by        *

*    differt endpoint on differnt alt settings                                *

*                                                                             *

\*****************************************************************************/

TInt TUsbcScBuffer::Construct(TInt aDirection, DLddUsbcScChannel* aLdd, TInt aBufferOffset, TInt aBufferEndOffset, TInt aMinReadSize, TInt aMaxPacketSize, TInt aMaxReadSize)

    {

    TInt r;

#ifdef _DEBUG

    iSequence = aBufferOffset; // Initialized at this, so that each buffer starts with a diffrent sequence number

#endif

    iMinReadSize = aMinReadSize;

    TInt size = (aBufferEndOffset - aBufferOffset);

    TInt pageSize = Kern::RoundToPageSize(1);

    if (aMaxReadSize > 0)

        iMaxReadSize = aMaxReadSize;

    else

        iMaxReadSize = pageSize + ((size/3) & ~(pageSize -1));

    iLdd = aLdd;

    iDirection = aDirection;

    iMode=0;

    iChunkInfo = aLdd->iChunkInfo;

    iChunkAddr = (TLinAddr) (aLdd->iChunkInfo->iChunkMem);  //aChunkAddr;

    TInt headerSize =  sizeof(TUsbcScTransferHeader)-4; // TransferHeader includes 4 bytes of data.

    TUint maxAlignment; // Note:  This is a mask for max Alignment, 

    if (aMaxPacketSize)

        { // EP0 packets are not DMAed, and so dont need ialignment.

        iAlignMask = ~3;

        maxAlignment = 3;

        }

    else

         maxAlignment = 1023; // We don't know what the alignment requirement will be until enumeration, so assume worse case.

    iFirstPacket = aBufferOffset + sizeof(SUsbcScBufferHeader) + headerSize;

    iFirstPacket = (iFirstPacket + maxAlignment) & ~maxAlignment;

    iBufferStart = (SUsbcScBufferHeader *) (iChunkAddr+aBufferOffset);

    iBufferEnd = aBufferEndOffset;

    if ((iDirection&1)==KUsbcScOut)

        iHead = iFirstPacket-headerSize;//aBufferOffset + sizeof(SUsbcScBufferHeader);

    else

        iSent = 0;

    iStalled=0;

    iMaxPacketSize=0;

    r =  iStatusList.Construct((aDirection==KUsbcScIn)?KUsbcScInRequests:KUsbcScOutRequests, iLdd->iClient);

    if (!r)

        {

        iMaxPacketSize = aMaxPacketSize; // Indicates configured if ep0, otherwise not.

        }

    return r;

    }

void TUsbcScBuffer::CreateChunkBufferHeader()

{

    if ((iDirection&1)==KUsbcScOut)

        {

        iBufferStart->iHead= iHead;

        iBufferStart->iTail= iHead; // Initially no data!

        iBufferStart->iBilTail=iHead;

        __KTRACE_OPT(KUSB, Kern::Printf("Realize:  iHead 0x%x  bufferHeader 0x%x", iHead,iBufferStart ));

        // Dont need to round here, as we will round it up on endpoint change. (configuration)

        }

}

/*

TUsbcScBuffer::StartEndpoint

This method sets the nessesary paramenters to the buffer, for use for a particular endpoint.

*/

void TUsbcScBuffer::StartEndpoint(TUsbcRequestCallback* aRequestInfo, TUint aFlags)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartEndpoint (0x%x) : ep %d(%d)",this,aRequestInfo->iEndpointNum, aRequestInfo->iRealEpNum));

    iCallback=aRequestInfo;

    iMaxPacketSize =  iLdd->iController->EndpointPacketSize(iLdd, aRequestInfo->iRealEpNum);

    iAlignMask = ~(((iMaxPacketSize+1) & 0xFFFFFFF8)-1);

    iMode = aFlags;

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartEndpoint : max Packets %d, mask 0x%x flags 0x%x", iMaxPacketSize, iAlignMask, iMode));

    if ((iDirection&1)==KUsbcScOut)

        {

        __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UsbcScOut\n"));

        // Add dummy packet (doesnt have to be aligned, which avoids what if it changes issue)

        // And Start next read.

        iNeedsPacket=KEpIsStarting;

        }

    }

void TUsbcScBuffer::Destroy()

{

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::Destroy()"));

    Cancel(KErrCancel);

    if (iLdd->iController && ((iDirection&1)==KUsbcScOut))  

        {  // Me must cancel reads to LDD to, an there will be no list for the callbacks to look into.

        iLdd->iController->CancelReadBuffer(iLdd, iCallback->iRealEpNum);

        }

    iStatusList.Destroy();

}

TInt TUsbcScBuffer::StartDataRead()

{

    if (!iMaxPacketSize)

    {

        __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataRead() - Not Configured"));

        return KErrNone;

    }

    if (iStatusList.iState!=ENotRunning) 

        {

        __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataRead() - Already Stated! (%d)",iStatusList.iState));

        return KErrNone;

        }

    TInt maxLength;

    TInt freeSpace;

    TPhysAddr physAddr;

    // get next request

    TUsbcScStatusElement* nextJob = iStatusList.Next();

    if (nextJob == NULL)

        {

        __KTRACE_OPT(KUSB, Kern::Printf("No more jobs"));

        if (iMode && KUsbScCoupledRead)

            return KErrEof;

        iStatusList.iState=EReadingAhead;

        }

    else

        iStatusList.iState=EInProgress;

    TInt tail = iBufferStart->iTail;

    TInt headerSize =  sizeof(TUsbcScTransferHeader)-4; // TransferHeader includes 4 bytes of data.

    maxLength = iChunkInfo->GetPhysical(iHead + headerSize, &physAddr); //returns all the bytes available after iHead + headerSize)

    __ASSERT_DEBUG(maxLength>0,Kern::Fault("TUsbcScBuffer::StartDataRead(", __LINE__)); 

    if (tail>iHead)  //  # # # H _ _ _ T # # # #

        {

        __KTRACE_OPT(KUSB,Kern::Printf("TUsbcScBuffer::StartDataRead() - tail 0x%x>head 0x%x, maxlength 0x%x", tail, iHead, maxLength));

        freeSpace = (tail & iAlignMask) - (iHead +headerSize + (~iAlignMask+1) );  // Cant read right up to last buffer, or head/tail will cross.

        if (freeSpace<iMinReadSize)

            {

            iStatusList.iState=ENotRunning;

            __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::StartDataRead() - Stall!!"));

            return KErrOverflow;                 // Read STALL !! !! !!

            }

        if (freeSpace<maxLength)

            maxLength = freeSpace;

        }

    if (maxLength> iMaxReadSize) 

        maxLength =  iMaxReadSize;

    // else  tail<iHead (or empty)      _ _ _ T # # # H _ _ _ _

    // We would not have set iHead here if too small. So must be ok.

    __ASSERT_DEBUG(maxLength>=iMinReadSize,Kern::Fault("TUsbcScBuffer::StartDataRead(", __LINE__)); 

    TUint8* data = ((TUsbcScTransferHeader *) (iHead + iChunkAddr))->iData.b;

    // set up callback stucture

    iCallback->SetRxBufferInfo(data, physAddr, iIndexArray, iSizeArray,maxLength);

    TInt r;

    // Go!!

    r = iLdd->iController->SetupReadBuffer(*iCallback);

    if (r!=KErrNone)

        {

        __KTRACE_OPT(KUSB,Kern::Printf("SetupReadBuffer Error: %d, RT %d",r, iStatusList.iState));

        iStatusList.Complete(r);

        }

    // After this, TUsbcScEndpoint::RequestCallback is called in a DFC.

    // This in turn calls either TUsbcScBuffer::CompleteRead.

    return KErrNone;

}

void TUsbcScBuffer::CompleteRead(TBool aStartNextRead)

{

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::CompleteRead buff=%x",this));

    // The first packet always contains the total #of bytes

    const TInt byteCount = iCallback->iPacketSize[0];

    const TInt packetCount = iCallback->iRxPackets;

     iCallback->iRxPackets=0;

    TUint flags = 0;

    if (iCallback->iPacketSize[packetCount - 1] < (TUint) iMaxPacketSize)

        flags = KUsbcScShortPacket;

    UpdateBufferList(byteCount, flags, aStartNextRead);

}

// This method "submits" the current transfer, and starts off the next read.

void TUsbcScBuffer::UpdateBufferList(TInt aByteCount,TUint aFlags, TBool aStartNextRead)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst aByteCount %d, flags 0x%x iHead 0x%x", aByteCount, aFlags, iHead));

    TInt headerSize =  sizeof(TUsbcScTransferHeader)-4; // TransferHeader includes 4 bytes of data.

    TLinAddr dummy;

    __KTRACE_OPT(KUSB, Kern::Printf("iHead 0x%x headerSize 0x%x",iHead, headerSize));

    // Find iNext

    TInt next =  iHead +  headerSize + aByteCount; // next unused byte in buffer.

    TInt maxLength; 

    // This may take a few loops before we settle on a value.

    do 

        {

        // round up.

        next = (next + headerSize + ~iAlignMask) & iAlignMask;

        maxLength = iChunkInfo->GetPhysical(next, &dummy);

        __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst  next %x  buffer end %x min-read: %x  maxRun %x", next, iBufferEnd, iMinReadSize, maxLength));

        // At the end of the buffer - wrap it if needbe.

        if ((TUint)(next + iMinReadSize) > iBufferEnd)

            {

            next = iFirstPacket;

            continue;

            }

        // Not enough space, move onto next block.

        if (maxLength<iMinReadSize) 

            {

            next+=maxLength;

            __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst Skip exhausted block. next %x max %d", next, maxLength));

            continue;

            }

        }

    while (EFalse);

    __KTRACE_OPT(KUSB, Kern::Printf("TUsbcScBuffer::UpdateBUfferLIst next (pre deduct): %x, Fill in header at head: 0x%x,  BuffStart: 0x%x.", next, iHead, iBufferStart));

    next -=  headerSize;  // Move next back from the data start position, to the header start.

    TUsbcScTransferHeader* header = (TUsbcScTransferHeader*) (iHead + iChunkAddr);

// Create Header

#ifdef _DEBUG

    header->iHashId=59*(iLdd->iAlternateSetting+1)+iCallback->iRealEpNum; // Alt setting realated....

    header->iSequence=iSequence;