/*

* Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

*

*/

#include <cs_port.h>

#include "AcmReader.h"

#include "AcmUtils.h"

#include "ActiveReader.h"

#include "ActiveReadOneOrMoreReader.h"

#include "CdcAcmClass.h"

#include "AcmPanic.h"

#include "AcmPort.h"

#include <usb/usblogger.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, "ECACM");

#endif

CAcmReader* CAcmReader::NewL(CAcmPort& aPort,

							 TUint aBufSize)

/**

 * Factory function.

 *

 * @param aPort The CAcmPort parent.

 * @param aBufSize The size of the buffer.

 * @return Ownership of a new CAcmReader.

 */

	{

	LOG_STATIC_FUNC_ENTRY

	CAcmReader* self = new(ELeave) CAcmReader(aPort, aBufSize);

	CleanupStack::PushL(self);

	self->ConstructL();

	CLEANUPSTACK_POP(self);

	return self;

	}

CAcmReader::~CAcmReader()

/**

 * Destructor.

 */

	{

	LOG_FUNC

	ReadCancel();

	delete iBuffer;

	}

CAcmReader::CAcmReader(CAcmPort& aPort,

					   TUint aBufSize)

/**

 * Constructor.

 *

 * @param aPort The CPort parent.

 * @param aBufSize The size of the buffer.

 */

 :	iBufSize(aBufSize),

	iInBuf(NULL,0,0),

	iPort(aPort)

	{

	}

void CAcmReader::ConstructL()

/**

 * 2nd-phase construction.

 */

	{

	// Create iBuffer. 

	LOGTEXT(_L8("\tabout to create iBuffer"));

	LEAVEIFERRORL(SetBufSize(iBufSize));

	}

void CAcmReader::Read(const TAny* aClientBuffer, TUint aMaxLen)

/**

 * Read API.

 *

 * @param aClientBuffer Pointer to the client's memory space.

 * @param aMaxLen Maximum length to read.

 */

	{

	LOG_FUNC

	LOGTEXT3(_L8("\taClientBuffer=0x%08x, aMaxLen=%d"), 

		aClientBuffer, aMaxLen);

	// Check we're open to requests and make a note of interesting data.

	// including iLengthToGo

	CheckNewRequest(aClientBuffer, aMaxLen);

	iCurrentRequest.iRequestType = ERead;

	// A read larger than our internal buffer limit will result in us doing

	// multiple reads to the ports below. 

	// We used to just refuse the request with a KErrNoMemory.

	if ( iTerminatorCount == 0 )

		{

		ReadWithoutTerminators();

		}

	else

		{

		ReadWithTerminators();

		}

	}

void CAcmReader::ReadWithoutTerminators()

/**

 * Process a read request given that no terminator characters are set.

 */

	{

	LOG_FUNC

	// Can we complete immediately from the buffer?

	const TUint bufLen = BufLen();

	LOGTEXT2(_L8("\thave %d bytes in buffer"), bufLen);

	LOGTEXT2(_L8("\tLength to go is %d bytes"), iLengthToGo);

	if ( iLengthToGo <= bufLen )

		{

		LOGTEXT2(_L8("\tcompleting request immediately from buffer with %d "

			"bytes"), iLengthToGo);

		WriteBackData(iLengthToGo);

		CompleteRequest(KErrNone);

		return;

		}

	// There isn't enough in the buffer to complete the request, so we write 

	// back as much as we have, and issue a Read for more.

	if ( bufLen )

		{

		LOGTEXT2(_L8("\twriting back %d bytes"), bufLen);

		// Write back as much data as we've got already.

		WriteBackData(bufLen);

		}

	// Issue a read for the data we still need. 

	LOGTEXT2(_L8("\tRequesting read - require %d bytes"),iLengthToGo);

	IssueRead();

	}

void CAcmReader::ReadWithTerminators()

/**

 * Process a read request given that terminator characters are set.

 */

	{

	LOG_FUNC

	// Can we complete immediately from the buffer? Search the buffer we have 

	// for any terminators. If found, complete back to the client. If not 

	// found, start issuing ReadOneOrMores until we either find one or run out 

	// of client buffer.

	const TUint bufLen = BufLen();

	LOGTEXT2(_L8("\tbufLen = %d"), bufLen);

	if ( bufLen )

		{

		CheckForBufferedTerminatorsAndProceed();

		return;

		}

	// There's no buffered data. Get some.

	IssueReadOneOrMore();

	}

void CAcmReader::ReadOneOrMore(const TAny* aClientBuffer, TUint aMaxLen)

/**

 * ReadOneOrMore API. Note that this is implemented to completely ignore 

 * terminator characters.

 *

 * @param aClientBuffer Pointer to the client's memory space.

 * @param aMaxLen Maximum length to read.

 */

	{

	LOG_FUNC

	LOGTEXT3(_L8("\taClientBuffer=0x%08x, aMaxLen=%d"), 

		aClientBuffer, aMaxLen);

	// Check we're open to requests and make a note of interesting data.

	CheckNewRequest(aClientBuffer, aMaxLen);

	iCurrentRequest.iRequestType = EReadOneOrMore;	

	// Check to see if there's anything in our buffer- if there is, we can 

	// complete immediately.

	const TUint bufLen = BufLen();

	LOGTEXT2(_L8("\tbufLen = %d"), bufLen);

	if ( bufLen )

		{

		// Complete request with what's in the buffer

		LOGTEXT2(_L8("\tcompleting request immediately from buffer with %d "

			"bytes"), bufLen);

		WriteBackData(bufLen);

		CompleteRequest(KErrNone);

		return;

		}

	// Get some more data.

	IssueReadOneOrMore();

	}

void CAcmReader::NotifyDataAvailable()

/** 

 * NotifyDataAvailable API. If a request is pending completes the client with KErrInUse.

 */

	{

	LOG_FUNC

	if(iCurrentRequest.iClientPtr) // a request is pending

		{

		iPort.NotifyDataAvailableCompleted(KErrInUse);

		return;

		}

	iCurrentRequest.iClientPtr = iBuffer;

	iCurrentRequest.iRequestType = ENotifyDataAvailable;	 	

	iPort.Acm()->NotifyDataAvailable(*this);		

	} 

void CAcmReader::NotifyDataAvailableCancel()

/**

 * NotifyDataAvailableCancel API. Issues a ReadCancel() to abort pending requests on the LDD  

 *

 */

	{

	LOG_FUNC	

	if (ENotifyDataAvailable == iCurrentRequest.iRequestType)

		{

		// Cancel any outstanding request on the LDD.		

		if (iPort.Acm())

			{

			LOGTEXT(_L8("\tiPort.Acm() exists- calling NotifyDataAvailableCancel() on it"));

			iPort.Acm()->NotifyDataAvailableCancel();

			}

		// Reset our flag to say there's no current outstanding request. What's 

		// already in our buffer can stay there.

		iCurrentRequest.iClientPtr = NULL;

		}	

	}

void CAcmReader::ReadCancel()

/**

 * Cancel API. Cancels any outstanding (Read or ReadOneOrMore) request.

 */

	{

	LOG_FUNC

	if (ENotifyDataAvailable != iCurrentRequest.iRequestType)

		{

		// Cancel any outstanding request on the LDD.

		if (iPort.Acm())

			{

			LOGTEXT(_L8("\tiPort.Acm() exists- calling ReadCancel on it"));

			iPort.Acm()->ReadCancel();

			}

		// Reset our flag to say there's no current outstanding request. What's 

		// already in our buffer can stay there.

		iCurrentRequest.iClientPtr = NULL;

		}

	}

TUint CAcmReader::BufLen() const

/**

 * This function returns the amount of data (in bytes) still remaining in the 

 * circular buffer.

 *

 * @return Length of data in buffer.

 */

	{

	LOGTEXT(_L8(">>CAcmReader::BufLen"));

	TUint len = 0;

	if ( BufWrap() )

		{

		LOGTEXT(_L8("\tbuf wrapped"));

		len = iBufSize - ( iOutPtr - iInPtr );

		}

	else

		{

		LOGTEXT(_L8("\tbuf not wrapped"));

		len = iInPtr - iOutPtr;

		}

	LOGTEXT2(_L8("<<CAcmReader::BufLen len=%d"), len);

	return len;

	}

void CAcmReader::ResetBuffer()

/**

 * Called by the port to clear the buffer.

 */

	{

	LOG_FUNC

	// A request is outstanding- C32 should protect against this.

	__ASSERT_DEBUG(!iCurrentRequest.iClientPtr, 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	// Reset the pointers. All data is 'lost'.

	iOutPtr = iInPtr = iBufStart;

	}

TInt CAcmReader::SetBufSize(TUint aSize)

/**

 * Called by the port to set the buffer size. Also used as a utility by us to 

 * create the buffer at instantiation. Note that this causes what was in the 

 * buffer at the time to be lost.

 *

 * @param aSize The required size of the buffer.

 */

	{

	LOG_FUNC

	LOGTEXT2(_L8("\taSize=%d"), aSize);

	if ( iCurrentRequest.iClientPtr )

		{

		// A request is outstanding. C32 does not protect us against this.

		LOGTEXT(_L8("\t***a request is outstanding- returning KErrInUse"));

		return KErrInUse;

		}

	// Create the new buffer.

	HBufC8* newBuf = HBufC8::New(aSize);

	if ( !newBuf )

		{

		LOGTEXT(_L8("\tfailed to create new buffer- returning KErrNoMemory"));

		return KErrNoMemory;

		}

	delete iBuffer;

	iBuffer = newBuf;

	// Update pointers etc.

	TPtr8 ptr = iBuffer->Des();

	iBufStart = const_cast<TUint8*>(reinterpret_cast<const TUint8*>(ptr.Ptr()));

	iBufSize = aSize;

	CheckBufferEmptyAndResetPtrs();

	return KErrNone;

	}

void CAcmReader::SetTerminators(const TCommConfigV01& aConfig)

/**

 * API to change the terminator characters.

 *

 * @param aConfig The new configuration.

 */

	{

	LOG_FUNC

	// C32 protects the port against having config set while there's a request 

	// outstanding.

	__ASSERT_DEBUG(!iCurrentRequest.iClientPtr, 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	iTerminatorCount = aConfig.iTerminatorCount;

	LOGTEXT2(_L8("\tnow %d terminators:"), iTerminatorCount);

	for ( TUint ii = 0; ii < static_cast<TUint>(KConfigMaxTerminators) ; ii++ )

		{

		iTerminator[ii] = aConfig.iTerminator[ii];

		LOGTEXT2(_L8("\t\t%d"), iTerminator[ii]);

		}

	}

void CAcmReader::ReadCompleted(TInt aError)

/**

 * Called by lower classes when an LDD Read completes. 

 *

 * @param aError Error.

 */

	{

	LOGTEXT2(_L8(">>CAcmReader::ReadCompleted aError=%d"), aError);						   	

	const TUint justRead = static_cast<TUint>(iInBuf.Length());

	LOGTEXT3(_L8("\tiInBuf length=%d, iLengthToGo=%d"), 

		justRead,

		iLengthToGo);

	// This protects against a regression in the LDD- read requests shouldn't 

	// ever complete with zero bytes and KErrNone.

	if ( justRead == 0 && aError == KErrNone )

		{

		_USB_PANIC(KAcmPanicCat, EPanicInternalError);

		}

	// The new data will have been added to our buffer. Move iInPtr up by the 

	// length just read.

	iInPtr += justRead;

	if ( aError )

		{

		// If the read failed, we complete back to the client and don't do 

		// anything more. (We don't want to get into retry strategies.) In a 

		// multi-stage Read the client will get any data already written back 

		// to them with IPCWrite.

		CompleteRequest(aError);

		return;

		}

	// calling this will write the data to the clients address space

	// it will also complete the request if we've given the client enough data

	// or will reissue another read if not

	ReadWithoutTerminators();

	LOGTEXT(_L8("<<CAcmReader::ReadCompleted"));

	}

void CAcmReader::ReadOneOrMoreCompleted(TInt aError)

/**

 * Called by lower classes when an LDD ReadOneOrMore completes. 

 *

 * @param aError Error.

 */

	{

	LOGTEXT2(_L8(">>CAcmReader::ReadOneOrMoreCompleted aError=%d"), aError);						   	

	const TUint justRead = static_cast<TUint>(iInBuf.Length());

	LOGTEXT2(_L8("\tjustRead = %d"), justRead);

	// The new data will have been added to our buffer. Move iInPtr 

	// up by the length just read.

	iInPtr += justRead;

	if ( aError )

		{

		// If the ReadOneOrMore failed, we complete back to the client and 

		// don't do anything more. The client will get any data already 

		// written back to them with IPCWrite.

		CompleteRequest(aError);

		return;

		}

	// TODO: may the LDD complete ROOM with zero bytes, eg if a ZLP comes in?

	// NB The LDD is at liberty to complete a ReadPacket request with zero 

	// bytes and KErrNone, if the given packet was zero-length (a ZLP). In 

	// this case, we have to reissue the packet read until we do get some 

	// data. 

	if ( justRead == 0 )

		{

		LOGTEXT(_L8("\twe appear to have a ZLP- reissuing ReadOneOrMore"));

		IssueReadOneOrMore();

		return;

		}

	if ( EReadOneOrMore == iCurrentRequest.iRequestType )

		{

		// Complete the client's request with as much data as we can. NB 

		// Opinion may be divided over whether to do this, or complete with 

		// just 1 byte. We implement the more generous approach.

		LOGTEXT2(_L8("\tcurrent request is ReadOneOrMore- completing with "

			"%d bytes"), justRead);

		WriteBackData(justRead);

		CompleteRequest(KErrNone);

		}

	else

		{

		// Outstanding request is a Read with terminators. (Except for 

		// ReadOneOrMore, we only request LDD::ReadOneOrMore in this case.)

		// Process the buffer for terminators. 

		LOGTEXT(_L8("\tcurrent request is Read with terminators"));

		CheckForBufferedTerminatorsAndProceed();

		}

	LOGTEXT(_L8("<<CAcmReader::ReadOneOrMoreCompleted"));

	}

void CAcmReader::NotifyDataAvailableCompleted(TInt aError)

	{

/**

 * Called by lower classes when data has arrived at the LDD after a 

 * NotifyDataAvailable request has been posted on the port. 

 *

 * @param aError Error.

 */

	LOGTEXT2(_L8(">>CAcmReader::NotifyDataAvailableCompleted aError=%d"), aError);	

	// If the NotifyDataAvailable request failed, we complete back 

	// to the client and don't do anything more.

	CompleteRequest(aError);		

	LOGTEXT(_L8("<<CAcmReader::NotifyDataAvailableCompleted"));	

	}

void CAcmReader::CheckBufferEmptyAndResetPtrs()

/**

 * Utility to assert that the buffer is empty and to reset the read and write 

 * pointers to the beginning of the buffer. We reset them there to cut down on 

 * fiddling around wrapping at the end of the buffer.

 */

	{

	LOGTEXT(_L8("CAcmReader::CheckBufferEmptyAndResetPtrs"));

	if ( BufLen() != 0 )

		{

		_USB_PANIC(KAcmPanicCat, EPanicInternalError);

		}

	iOutPtr = iInPtr = iBufStart;

	}

void CAcmReader::CheckNewRequest(const TAny* aClientBuffer, TUint aMaxLen)

/**

 * Utility function to check a Read or ReadOneOrMore request from the port. 

 * Also checks that there isn't a request already outstanding. Makes a note of 

 * the relevant parameters and sets up internal counters.

 *

 * @param aClientBuffer Pointer to the client's memory space.

 * @param aMaxLen Maximum length to read.

 */

	{

	// The port should handle zero-length reads, not us.

	__ASSERT_DEBUG(aMaxLen > 0, _USB_PANIC(KAcmPanicCat, EPanicInternalError));

	__ASSERT_DEBUG(aMaxLen <= static_cast<TUint>(KMaxTInt), 

		_USB_PANIC(KAcmPanicCat, EPanicInternalError));

	// Check we have no outstanding request already.

	if ( iCurrentRequest.iClientPtr )// just panic in case of concurrent Read or ReadOneOrMore queries.

		{							 // in case of NotifyDataAvailable queries, we already have completed the client with KErrInUse.

									 // This code is kept for legacy purpose. That justifies the existence of IsNotifyDataAvailableQueryPending

		_USB_PANIC(KAcmPanicCat, EPanicInternalError);