/**

 @file usbdma.cpp

 @internalTechnology

*/

#include <usb/usbc.h>

#if defined(_DEBUG)

static const char KUsbPanicLdd[] = "USB LDD";

#endif

TDmaBuf::TDmaBuf(TUsbcEndpointInfo* aEndpointInfo, TInt aBandwidthPriority)

    : iBufBasePtr(NULL),

      iCurrentDrainingBuffer(NULL),

      iCurrentPacket(0),

      iCurrentPacketIndexArray(NULL),

      iCurrentPacketSizeArray(NULL)

    {

    iMaxPacketSize = aEndpointInfo->iSize;

    iEndpointType = aEndpointInfo->iType;

    switch (aEndpointInfo->iType)

        {

    case UsbShai::KUsbEpTypeControl:

        iBufSz = KUsbcDmaBufSzControl;

        iNumberofBuffers = KUsbcDmaBufNumControl;

        break;

    case UsbShai::KUsbEpTypeIsochronous:

        iBufSz = KUsbcDmaBufSzIsochronous;

        iNumberofBuffers = KUsbcDmaBufNumIsochronous;

        break;

    case UsbShai::KUsbEpTypeBulk:

        {

        if (aEndpointInfo->iDir == UsbShai::KUsbEpDirOut)

            {

            const TInt priorityOUT = aBandwidthPriority & 0x0f;

            iBufSz = KUsbcDmaBufSizesBulkOUT[priorityOUT];

            }

        else

            {

            const TInt priorityIN = (aBandwidthPriority >> 4) & 0x0f;

            iBufSz = KUsbcDmaBufSizesBulkIN[priorityIN];

            }

        iNumberofBuffers = KUsbcDmaBufNumBulk;

        }

        break;

    case UsbShai::KUsbEpTypeInterrupt:

        iBufSz = KUsbcDmaBufSzInterrupt;

        iNumberofBuffers = KUsbcDmaBufNumInterrupt;

        break;

    default:

        iBufSz = 0;

        iNumberofBuffers = 0;

        }

    if (aEndpointInfo->iDir == UsbShai::KUsbEpDirIn)

        {

        iNumberofBuffers = 1;                                // IN endpoints only have 1 buffer

        }

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

        {

        // Buffer logical addresses (pointers)

        iBuffers[i] = NULL;

        // Buffer physical addresses

        iBufferPhys[i] = 0;

        // Packet indexes base array

        iPacketIndex[i] = NULL;

        // Packet sizes base array

        iPacketSize[i] = NULL;

        }

    }

TInt TDmaBuf::Construct(TUsbcEndpointInfo* aEndpointInfo)

    {

    if (aEndpointInfo->iDir != UsbShai::KUsbEpDirIn)

        {

        // IN endpoints don't need a packet array

        // At most 2 packets (clump of max packet size packets) + possible zlp

        TUsbcPacketArray* bufPtr = iPacketInfoStorage;

        // this divides up the packet indexing & packet size array over the number of buffers

        __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::Construct() array base=0x%08x", bufPtr));

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

            {

            iPacketIndex[i] = bufPtr;

            bufPtr += KUsbcDmaBufMaxPkts;

            iPacketSize[i] = bufPtr;

            bufPtr += KUsbcDmaBufMaxPkts;

            __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::Construct() packetIndex[%d]=0x%08x packetSize[%d]=0x%08x",

                                            i, iPacketIndex[i], i, iPacketSize[i]));

            }

        }

    else

        {

        __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::Construct() IN endpoint"));

        }

    Flush();

    return KErrNone;

    }

TDmaBuf::~TDmaBuf()

    {

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

    }

TInt TDmaBuf::BufferTotalSize() const

    {

    return iBufSz * iNumberofBuffers;

    }

TInt TDmaBuf::BufferSize() const

    {

    return iBufSz;

    }

TInt TDmaBuf::SetBufferAddr(TInt aBufInd, TUint8* aBufAddr)

    {

    __ASSERT_DEBUG((aBufInd < iNumberofBuffers),

                       Kern::Fault(KUsbPanicLdd, __LINE__));

    iDrainable[aBufInd] = iCanBeFreed[aBufInd] = EFalse;

    iBuffers[aBufInd] = aBufAddr;

    iBufferPhys[aBufInd] = Epoc::LinearToPhysical((TLinAddr)aBufAddr);

    __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::SetBufferAddr() iBuffers[%d]=0x%08x", aBufInd, iBuffers[aBufInd]));

    return KErrNone;

    }

TInt TDmaBuf::BufferNumber() const

    {

    return iNumberofBuffers;

    }

void TDmaBuf::SetMaxPacketSize(TInt aSize)

    {

    iMaxPacketSize = aSize;

    }

void TDmaBuf::Flush()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::Flush %x", this));

    iRxActive = EFalse;

    iTxActive = EFalse;

    iExtractOffset = 0;

    iTotalRxBytesAvail = 0;

    iTotalRxPacketsAvail = 0;

    iCurrentDrainingBufferIndex = KUsbcInvalidBufferIndex;

    iCurrentFillingBufferIndex = 0;

    iDrainQueueIndex = KUsbcInvalidDrainQueueIndex;

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

        {

        iDrainable[i] = EFalse;

        iCanBeFreed[i] = EFalse;

        iNumberofBytesRx[i] = 0;

        iNumberofPacketsRx[i] = 0;

        iError[i] = KErrGeneral;

        iDrainQueue[i] = KUsbcInvalidBufferIndex;

#if defined(USBC_LDD_BUFFER_TRACE)

        iFillingOrderArray[i] = 0;

        iNumberofBytesRxRemain[i] = 0;

        iNumberofPacketsRxRemain[i] = 0;

#endif

        }

    // Drain queue is 1 oversized

    iDrainQueue[KUsbcDmaBufNumMax] = KUsbcInvalidBufferIndex;

#if defined(USBC_LDD_BUFFER_TRACE)

    iFillingOrder = 0;

    iDrainingOrder = 0;

#endif

    }

void TDmaBuf::RxSetActive()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxSetActive %x", this));

    iRxActive = ETrue;

    }

void TDmaBuf::RxSetInActive()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxSetInActive %x", this));

    iRxActive = EFalse;

    }

TBool TDmaBuf::RxIsActive()

    {

    return iRxActive;

    }

void TDmaBuf::TxSetActive()

    {

    iTxActive = ETrue;

    }

void TDmaBuf::TxSetInActive()

    {

    iTxActive = EFalse;

    }

TBool TDmaBuf::TxIsActive()

    {

    return iTxActive;

    }

/**************************** Rx DMA Buffer Access *************************/

void TDmaBuf::ModifyTotalRxBytesAvail(TInt aVal)

    {

    iTotalRxBytesAvail += aVal;

    }

void TDmaBuf::ModifyTotalRxPacketsAvail(TInt aVal)

    {

    iTotalRxPacketsAvail += aVal;

    }

TBool TDmaBuf::AdvancePacket()

    {

    ModifyTotalRxPacketsAvail(-1);

    TBool r = ETrue;

    __ASSERT_DEBUG((iCurrentDrainingBufferIndex >= 0),

                       Kern::Fault(KUsbPanicLdd, __LINE__));

    if (++iCurrentPacket >= iNumberofPacketsRx[iCurrentDrainingBufferIndex])

        {

        r = NextDrainableBuffer();

        }

    iExtractOffset = 0;

    __ASSERT_DEBUG((iCurrentDrainingBufferIndex == KUsbcInvalidBufferIndex) ||

                   (iCurrentPacket < KUsbcDmaBufMaxPkts),

                   Kern::Fault(KUsbPanicLdd, __LINE__));

    return r;

    }

TInt TDmaBuf::PeekNextPacketSize()

    {

    TUint pkt = iCurrentPacket;

    TInt index = iCurrentDrainingBufferIndex;

    TInt size = -1;

    if (pkt >= iNumberofPacketsRx[index])

        {

        index = PeekNextDrainableBuffer();

        pkt = 0;

        }

    if ((index != KUsbcInvalidBufferIndex) && iNumberofPacketsRx[index])

        {

        const TUsbcPacketArray* sizeArray = iPacketSize[index];

        size = (TInt)sizeArray[pkt];

        }

    __ASSERT_DEBUG((iCurrentDrainingBufferIndex == KUsbcInvalidBufferIndex) ||

                   (iCurrentPacket < KUsbcDmaBufMaxPkts),

                   Kern::Fault(KUsbPanicLdd, __LINE__));

    return size;

    }

inline TInt TDmaBuf::GetCurrentError()

    {

    // USB bus errors are v.rare. To avoid having an error code attached to every packet since

    // almost every errorcode will be KErrNone, we have a single error code per buffer

    // If the error code is != KErrNone then it refers to the LAST packet in the buffer

    TInt errorCode = KErrNone;

    //Check the index, it's not equal to negative (-1) value defined in 

    //KUsbcInvalidBufferIndex.

    __ASSERT_DEBUG((iCurrentDrainingBufferIndex >= 0),

                       Kern::Fault(KUsbPanicLdd, __LINE__));

    if (iError[iCurrentDrainingBufferIndex] != KErrNone)

        {

        // See if we are at the last packet

        if ((iCurrentPacket + 1) == iNumberofPacketsRx[iCurrentDrainingBufferIndex])

            {

            errorCode = iError[iCurrentDrainingBufferIndex];

            }

        }

    return errorCode;

    }

// used to decide whether a client read can complete straight away

TBool TDmaBuf::IsReaderEmpty()

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::IsReaderEmpty iTotalRxPacketsAvail=%d",

                                    iTotalRxPacketsAvail));

    return (iTotalRxPacketsAvail == 0);

    }

void TDmaBuf::ReadXferComplete(TInt aNoBytesRecv, TInt aNoPacketsRecv, TInt aErrorCode)

    {

    // Adjust pending packet

    if ((aNoBytesRecv == 0) && (aErrorCode != KErrNone))

        {

        // Make the buffer available for reuse

        iDrainable[iCurrentFillingBufferIndex] = EFalse;

        return;

        }

    ModifyTotalRxBytesAvail(aNoBytesRecv);

    ModifyTotalRxPacketsAvail(aNoPacketsRecv);

    iNumberofBytesRx[iCurrentFillingBufferIndex] = aNoBytesRecv;

    iNumberofPacketsRx[iCurrentFillingBufferIndex] = aNoPacketsRecv;

#if defined(USBC_LDD_BUFFER_TRACE)

    iNumberofBytesRxRemain[iCurrentFillingBufferIndex] = aNoBytesRecv;

    iNumberofPacketsRxRemain[iCurrentFillingBufferIndex] = aNoPacketsRecv;

#endif

    __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::ReadXferComplete 2 # of bytes=%d # of packets=%d",

                                    iTotalRxBytesAvail, iTotalRxPacketsAvail));

    iDrainable[iCurrentFillingBufferIndex] = ETrue;

    iError[iCurrentFillingBufferIndex] = aErrorCode;

    AddToDrainQueue(iCurrentFillingBufferIndex);

    if (iCurrentDrainingBufferIndex == KUsbcInvalidBufferIndex)

        {

        NextDrainableBuffer();

        }

    }

TInt TDmaBuf::RxGetNextXfer(TUint8*& aBufferAddr, TUsbcPacketArray*& aIndexArray,

                            TUsbcPacketArray*& aSizeArray, TInt& aLength, TPhysAddr& aBufferPhys)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxGetNextXfer 1"));

    if (RxIsActive())

        {

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

        return KErrInUse;

        }

    __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxGetNextXfer Current buffer=%d",

                                    iCurrentFillingBufferIndex));

    if (iDrainable[iCurrentFillingBufferIndex])

        {

        // If the controller refused the last read request, then the current buffer will still be marked

        // as !Drainable, because the controller never completed the read to the ldd. and therefore the buffer

        // can be reused.

        if (!NextFillableBuffer())

            {

            return KErrNoMemory;

            }

        }

    __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxGetNextXfer New buffer=%d",

                                    iCurrentFillingBufferIndex));

    aBufferAddr = iBuffers[iCurrentFillingBufferIndex];

    aBufferPhys = iBufferPhys[iCurrentFillingBufferIndex];

    aIndexArray = iPacketIndex[iCurrentFillingBufferIndex];

    aSizeArray = iPacketSize[iCurrentFillingBufferIndex];

    aLength = iBufSz;

#if defined(USBC_LDD_BUFFER_TRACE)

    iFillingOrderArray[iCurrentFillingBufferIndex] = ++iFillingOrder;

#endif

    return KErrNone;

    }

TInt TDmaBuf::RxCopyPacketToClient(DThread* aThread, TClientBuffer *aTcb, TInt aLength)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxCopyPacketToClient 1"));

#if defined(USBC_LDD_BUFFER_TRACE)

    const TInt numPkts = NoRxPackets();

    const TInt numPktsAlt = NoRxPacketsAlt();

    const TInt numBytes = RxBytesAvailable();

    const TInt numBytesAlt = NoRxBytesAlt();

    if (numPkts != numPktsAlt)

        {

        Kern::Printf(

            "TDmaBuf::RxCopyPacketToClient: Error: #pkts mismatch global=%d actual=%d",

            numPkts, numPktsAlt);

        }

    if (numBytes != numBytesAlt)

        {

        Kern::Printf(

            "TDmaBuf::RxCopyPacketToClient: Error: #bytes mismatch global=%d actual=%d",

            numBytes, numBytesAlt);

        }

    if ((numPkts == 0) && (numBytes !=0))

        {

        Kern::Printf(

            "TDmaBuf::RxCopyPacketToClient: Error: global bytes & pkts mismatch pkts=%d bytes=%d",

            numPkts, numBytes);

        }

    if ((numPktsAlt == 0) && (numBytesAlt !=0))

        {

        Kern::Printf(

            "TDmaBuf::RxCopyPacketToClient: Error: actual bytes & pkts mismatch pkts=%d bytes=%d",

            numPktsAlt, numBytesAlt);

        }

#endif

    if (!NoRxPackets())

        return KErrNotFound;

    __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxCopyPacketToClient 2"));

    // the next condition should be true because we have some packets available

    // coverity[var_tested_neg]

    if (iCurrentDrainingBufferIndex == KUsbcInvalidBufferIndex)

        {

        // Marked as Coverity "Intentional" as the member variable

        // iCurrentDrainingBufferIndex is attentionaly negative, from previous 

        // initialization to KUsbcInvalidBufferIndex (which equals -1).

        if (!NextDrainableBuffer())

            return KErrNotFound;

        }

    __ASSERT_DEBUG((iCurrentDrainingBufferIndex >= 0 ),

                           Kern::Fault(KUsbPanicLdd, __LINE__));

    if (!iDrainable[iCurrentDrainingBufferIndex])

        return KErrNotFound;

    // Calculate copy-from address & adjust for the fact that

    // some data may have already been read from the packet

    TUint8* logicalSrc = iCurrentDrainingBuffer + iCurrentPacketIndexArray[iCurrentPacket] + iExtractOffset;

    TInt packetSz = iCurrentPacketSizeArray[iCurrentPacket];

    TInt thisPacketSz = packetSz - iExtractOffset;

    TInt errorCode;

    // try and sort out what a "packet" might mean.

    // in a multi-packet dma environment, we might see super-packets

    // i.e. we might just see one packet, maybe 4K or so long, made of lots of small packets

    // Since we don't know where the packet boundaries will be, we have to assume that

    // any 'packet' larger than the max packet size of the ep is, in fact, a conglomeration

    // of smaller packets. However, for the purposes of the packet count, this is still regarded

    // as a single packet and the packet count only decremented when it is consumed.

    // As before, if the user fails to read an entire packet out then the next packet is moved onto anyway

    // To be safe the user must always supply a buffer of at least max packet size bytes.

    if (thisPacketSz > iMaxPacketSize)

        {

        // Multiple packets left in buffer

        // calculate number of bytes to end of packet

        if (iEndpointType == UsbShai::KUsbEpTypeBulk)

            {

            thisPacketSz = iMaxPacketSize - (iExtractOffset & (iMaxPacketSize - 1));

            }

        else

            {

            thisPacketSz = iMaxPacketSize - (iExtractOffset % iMaxPacketSize);

            }

        errorCode = KErrNone;

        }

    else

        {

        errorCode = GetCurrentError();                        // single packet left

        }

    iExtractOffset += thisPacketSz;            // iExtractOffset is now at the end of the real or notional packet

    ModifyTotalRxBytesAvail(-thisPacketSz);

#if defined(USBC_LDD_BUFFER_TRACE)

    iNumberofBytesRxRemain[iCurrentDrainingBufferIndex] -= thisPacketSz;

#endif

    // this can only be untrue if the "packet" is a conglomeration of smaller packets:

    if (iExtractOffset == packetSz)

        {

        // packet consumed, advance to next packet in buffer

#if defined(USBC_LDD_BUFFER_TRACE)

        iNumberofPacketsRxRemain[iCurrentDrainingBufferIndex] -= 1;

#endif

        AdvancePacket();

        }

    TPtrC8 des(logicalSrc, thisPacketSz);

    TInt r=Kern::ThreadBufWrite(aThread, aTcb, des, 0, 0, aThread);

    if (r == KErrNone)

        {

        r = errorCode;

        }

    __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxCopyPacketToClient 3"));

    FreeDrainedBuffers();

    // Use this error code to complete client read request:

    return r;

    }

TInt TDmaBuf::RxCopyDataToClient(DThread* aThread, TClientBuffer *aTcb, TInt aLength, TUint32& aDestOffset,

                                 TBool aRUS, TBool& aCompleteNow)

    {

    __KTRACE_OPT(KUSB, Kern::Printf("TDmaBuf::RxCopyDataToClient 1"));

    aCompleteNow = ETrue;

#if defined(USBC_LDD_BUFFER_TRACE)

    const TInt numPkts = NoRxPackets();

    const TInt numPktsAlt = NoRxPacketsAlt();

    const TInt numBytes = RxBytesAvailable();