// Copyright (c) 2007-2010 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:
// 

/**
@file
@internalComponent
*/

#include "fdchctloriginal.h"

#include <d32usbdescriptors.h>
#include <usbhost/internal/fdcpluginobserver.h>
#include <usbhosterrors.h>
#include <bluetooth/logger.h>

#include "fdchctloriginalserver.h"

#include <bluetooth/logger.h>

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, "fdchctloriginal");
#endif


CFdcHctlOriginal* CFdcHctlOriginal::NewL(MFdcPluginObserver& aObserver)
	{
	LOG_STATIC_FUNC
	CFdcHctlOriginal* self = new(ELeave) CFdcHctlOriginal(aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

CFdcHctlOriginal::CFdcHctlOriginal(MFdcPluginObserver& aObserver)
	: CFdcPlugin(aObserver)
	{
	LOG_FUNC
	}

CFdcHctlOriginal::~CFdcHctlOriginal()
	{
	LOG_FUNC
	iHctlSession.Close();
	delete iServer;
	}

void CFdcHctlOriginal::ConstructL()
	{
	LOG_FUNC
	iServer = CFdcHctlOriginalServer::NewL(*this);
	}

TAny* CFdcHctlOriginal::GetInterface(TUid aUid)
	{
	LOG_FUNC
	LOG1(_L8("\taUid = 0x%08x"), aUid);
	
	TAny* ret = NULL;
	if(aUid == TUid::Uid(KFdcInterfaceV1))
		{
		ret = reinterpret_cast<TAny*>(static_cast<MFdcInterfaceV1*>(this));
		}
	
	LOG1(_L8("\tret = [0x%08x]"), ret);
	return ret;
	}

TInt CFdcHctlOriginal::Mfi1NewFunction(TUint aDeviceId,
		const TArray<TUint>& aInterfaces,
		const TUsbDeviceDescriptor& aDeviceDescriptor,
		const TUsbConfigurationDescriptor& aConfigurationDescriptor)
	{
	LOG_FUNC
	
	// Normally an FDC is required to claim it's interfaces first.  In this
	// case we need to parse the descriptor tree to determine if the device
	// firmware update interface is present. (We don't do firmware updates but
	// we claim it until to provide successful device attachments. If a
	// firmware update FDC is provided this should be removed.)
#ifdef SYMBIAN_FDC_HCTL_ORIGINAL_ACCEPT_FIRMWARE_UPDATE
	TBool firmwareIntFound = EFalse;
	TUint8 firmwareIntNum = 0xff;
	
	TUint8 KDfuInterfaceClass = 0xfe;
	TUint8 KDfuInterfaceSubClass = 0x01;
	
	// Drop down a level from the configuration descriptor.
	TUsbGenericDescriptor* descriptor = aConfigurationDescriptor.iFirstChild;
	// Search across the interface tier (note doesn't handle DFU in IAD).
	while(descriptor)
		{
		TUsbInterfaceDescriptor* interface;
		if (interface = TUsbInterfaceDescriptor::Cast(descriptor), interface)
			{
			if(	interface->InterfaceClass() == KDfuInterfaceClass &&
				interface->InterfaceSubClass() == KDfuInterfaceSubClass)
				{
				firmwareIntNum = interface->InterfaceNumber();
				firmwareIntFound = ETrue;
				break;
				}
			}
		descriptor = descriptor->iNextPeer;
		}
#endif // SYMBIAN_FDC_HCTL_ORIGINAL_ACCEPT_FIRMWARE_UPDATE
	
	// We claim the interfaces we are to represent, we must claim the
	// first interface given to us as FDF has already determined that
	// we are to use it.
	const TUint KNumOfHctlInterfaces = 2;
	const TUint8 KAclInterfaceNum = 0x00, KScoInterfaceNum = 0x01;
	TBool gotAcl = EFalse, gotSco = EFalse, fatalError = EFalse;
	
	for(TInt i=0; i<aInterfaces.Count(); ++i)
		{
		TUint intNum = aInterfaces[i];
		if(intNum == KAclInterfaceNum)
			{
			fatalError = (fatalError || gotAcl); // The USB device should only report one ACL interface
			iAclToken = Observer().TokenForInterface(intNum);
			gotAcl = ETrue;
			}
		else if(intNum == KScoInterfaceNum)
			{
			fatalError = (fatalError || gotSco); // The USB device should only report one ACL interface
			iScoToken = Observer().TokenForInterface(intNum);
			gotSco = ETrue;
			}
		else if(i == 0)
			{
			// We always need to claim the first interface, this should have
			// been claimed already, but if we have a funny device then this
			// might not be the case.  We will need to error.
			TUint32 unknownToken = Observer().TokenForInterface(intNum);
			return KErrCorrupt;
			}
#ifdef SYMBIAN_FDC_HCTL_ORIGINAL_ACCEPT_FIRMWARE_UPDATE
		else if(firmwareIntFound && intNum == firmwareIntNum)
			{
			TUint32 dfuToken = Observer().TokenForInterface(intNum);
			}
#endif // SYMBIAN_FDC_HCTL_ORIGINAL_ACCEPT_FIRMWARE_UPDATE
		}
	// At this point we will have claimed to the interface mandated by FDF and
	// so we are at liberty to return an error.
	
	// firstly, check to see if a fatal error occured.
	if(fatalError)
		{
		LOG(_L8("\tFatal error when retrieving interfaces for driver instance..."));
		return KErrGeneral;
		}
	
	// Now we perform some validation that the function is what we expect.
	// There should be two interfaces as part of the function. One is
	// the standard data and control planes.  The other for the sync-
	// chronous connections.
	if(aConfigurationDescriptor.NumInterfaces() < KNumOfHctlInterfaces)
		{
		LOG(_L8("\tInsufficent interfaces in USB config. descriptor..."));
		return KErrUsbBadDescriptor;
		}
	if(aInterfaces.Count() < KNumOfHctlInterfaces)
		{
		LOG(_L8("\tInsufficient interfaces provided to FDC..."));
		return KErrUnderflow;
		}
	
	// Ensure that we got both interfaces, otherwise the device is malformed.
	if(!gotAcl || !gotSco)
		{
		LOG2(_L8("\tMissing Token [ACL=%d] [SCO=%d]"), gotAcl, gotSco);
		return KErrNotFound;
		}
	
	// At this point we are set-up to use the device.
	iReady = ETrue;
	
	// We try our best; the Bluetooth stack may not be running, it may not be even using
	// the USB HCTL.  So we accept the tokens and try the best to set-up the HCTL.
	// If we fail now the HCTL should later inform us to try again.
	RequestConnection();
	
	return KErrNone;
	}

void CFdcHctlOriginal::Mfi1DeviceDetached(TUint aDeviceId)
	{
	LOG_FUNC
	
	iReady = EFalse;
	
	if(iHctlSession.Handle())
		{
		// Inform of disconnection.
		iHctlSession.DeviceDetached();
		}
	// Close Hctl Handle
	iHctlSession.Close();
	}

void CFdcHctlOriginal::RequestConnection()
	{
	LOG_FUNC
	// Trigger the attempt to connect to the USB HCTL Server.
	
	if(!iReady)
		{
		// For whatever reason, we have not got the tokens for the USB interfaces.
		LOG(_L8("\tFDC is not ready"));
		return;
		}
	
	// Note that this will error if, the bt thread or usb hctl is not running;
	// or if there is another FDC already connected to it.
	TInt err = iHctlSession.Connect();
	if(err != KErrNone)
		{
		LOG1(_L8("\tRHCTLUsbOriginal::Connect error = %d"), err);
		return;
		}
	
	// Now inform the stack that we have a connected device.
	err = iHctlSession.DeviceAttached(iAclToken, iScoToken);
	if(err != KErrNone)
		{
		LOG1(_L8("\tRHCTLUsbOriginal::DeviceAttached error = %d"), err);
		iHctlSession.Close();
		return;
		}
	}