/*
* Copyright (c) 1997-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:
* Implements part of UsbMan USB Class Framework.
*
*/

/**
 @file
*/

#include "CUsbWHCMClassController.h"
#include <usb_std.h>
#include <cusbclasscontrolleriterator.h>
#include <musbclasscontrollernotify.h>
#include <usb/usblogger.h>

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

_LIT(KUsbLDDName, "eusbc");

_LIT( KWhcmCcPanicCategory, "UsbWhcmCc" );

/**
 * Panic codes for the USB WHCM Class Controller.
 */
enum TWhcmCcPanic
	{
	/** Start() called while in an illegal state */
	EBadApiCallStart = 0,
	/** Asynchronous function called (not needed, as all requests complete synchronously) */
	EUnusedFunction = 1,
	/** Stop() called while in an illegal state */
	EBadApiCallStop = 2
	};

/**
 * Constructs a CUsbWHCMClassController object.
 *
 * @param aOwner USB Device that owns and manages the class
 * @return A new CUsbWHCMClassController object
 */
CUsbWHCMClassController* CUsbWHCMClassController::NewL(
	MUsbClassControllerNotify& aOwner)
	{
	LOG_STATIC_FUNC_ENTRY

	CUsbWHCMClassController* self =
		new (ELeave) CUsbWHCMClassController(aOwner);

	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

/**
 * Constructor.
 *
 * @param aOwner USB Device that owns and manages the class
 */
CUsbWHCMClassController::CUsbWHCMClassController(
		MUsbClassControllerNotify& aOwner)
	: CUsbClassControllerPlugIn(aOwner, KWHCMPriority)
	{
	iState = EUsbServiceIdle;
	}

/**
 * Method to perform second phase construction.
 */
void CUsbWHCMClassController::ConstructL()
	{
	// Load the device driver
	TInt err = User::LoadLogicalDevice(KUsbLDDName);
	if (err != KErrNone && err != KErrAlreadyExists) 
		{
		LEAVEL(err);      
		} 

	LEAVEIFERRORL(iLdd.Open(0));
	}

/**
 * Destructor.
 */
CUsbWHCMClassController::~CUsbWHCMClassController()
	{
	Cancel();

	if (iState == EUsbServiceStarted)
		{
		// Must release all interfaces before closing the LDD to avoid a crash.
		iLdd.ReleaseInterface(0);
		}
	iLdd.Close();
	}

/**
 * Called by UsbMan to start this class.
 *
 * @param aStatus Will be completed with success or failure.
 */
void CUsbWHCMClassController::Start(TRequestStatus& aStatus)
	{
	LOG_FUNC
		
	//Start() should never be called if started, starting or stopping (or in state EUsbServiceFatalError)
	__ASSERT_DEBUG( iState == EUsbServiceIdle, _USB_PANIC(KWhcmCcPanicCategory, EBadApiCallStart) );
	
	TRequestStatus* reportStatus = &aStatus;

	iState = EUsbServiceStarting;

	TRAPD(err, SetUpWHCMDescriptorL());

	if (err != KErrNone) 
		{
		iState = EUsbServiceIdle;
		User::RequestComplete(reportStatus, err);
		return;
		}
	iState = EUsbServiceStarted;
	User::RequestComplete(reportStatus, KErrNone);
	}

/**
 * Called by UsbMan to stop this class.
 *
 * @param aStatus Will be completed with success or failure.
 */
void CUsbWHCMClassController::Stop(TRequestStatus& aStatus)
	{
	LOG_FUNC

	//Stop() should never be called if stopping, idle or starting (or in state EUsbServiceFatalError)
	__ASSERT_DEBUG( iState == EUsbServiceStarted, _USB_PANIC(KWhcmCcPanicCategory, EBadApiCallStop) );

	TRequestStatus* reportStatus = &aStatus;

	// Must release all interfaces before closing the LDD to avoid a crash.
	iLdd.ReleaseInterface(0);

	iState = EUsbServiceIdle;

	aStatus = KRequestPending;

	User::RequestComplete(reportStatus, KErrNone);
	}

/**
 * Returns information about the interfaces supported by this class.
 *
 * @param aDescriptorInfo Will be filled in with interface information.
 */
void CUsbWHCMClassController::GetDescriptorInfo(
	TUsbDescriptor& /*aDescriptorInfo*/) const
	{
	}

/**
 * Standard active object RunL.
 */
void CUsbWHCMClassController::RunL()
	{
	// This function should never be called.
	_USB_PANIC(KWhcmCcPanicCategory, EUnusedFunction);
	}

/**
 * Standard active object cancellation function. Will only be called when an
 * asynchronous request is currently active.
 */
void CUsbWHCMClassController::DoCancel()
	{
	// This function should never be called.
	_USB_PANIC(KWhcmCcPanicCategory, EUnusedFunction);
	}

/**
 * Standard active object error-handling function. Should return KErrNone to
 * avoid an active scheduler panic.
 */
TInt CUsbWHCMClassController::RunError(TInt /*aError*/)
	{
	// This function should never be called.
	_USB_PANIC(KWhcmCcPanicCategory, EUnusedFunction);

	return KErrNone;
	}


void CUsbWHCMClassController::SetUpWHCMDescriptorL()
/**
 * Setup the WHCM Class Descriptors.
 */
    {
	// Set up and register the WHCM interface descriptor

    TUsbcInterfaceInfoBuf ifc;
	ifc().iString = NULL;
	ifc().iClass.iClassNum = 0x02;
	ifc().iClass.iSubClassNum =  KWHCMSubClass;
	ifc().iClass.iProtocolNum = KWHCMProtocol;
	ifc().iTotalEndpointsUsed = 0;

	// Indicate that this interface does not expect any control transfers 
	// from EP0.
	ifc().iFeatureWord |= KUsbcInterfaceInfo_NoEp0RequestsPlease;

	LEAVEIFERRORL(iLdd.SetInterface(0, ifc));

	// Get the interface number from the LDD for later reference
	TBuf8<100> interface_descriptor;
	LEAVEIFERRORL(iLdd.GetInterfaceDescriptor(0, interface_descriptor));
	
		
	TUint8 WHCM_int_no = interface_descriptor[2];

	// Set up the class-specific interface block.
	// This consists of:
	//		Comms Class Header Functional Desctriptor
	//		WHCM Functional Descriptor
	//		Union Functional Descriptor
	// Most of the data is copied from the static const structure in the header file.

	TBuf8<200> desc;
	desc.Copy(WHCMheader, sizeof(WHCMheader));

	// Append the interface number to the Union Functional Descriptor
	desc.Append( WHCM_int_no );

    // In order to finish off the Union Functional Descriptor we need to fill
	// out the Subordinate Class list.
	// We can do this by iterating through the remaining class controllers in the
	// owner's list to find all the the subordinate classes.

	// Two assumptions are made here:
	//		1) That all the remaining controller in the list (after this one)
	//		   are subordinate classes of this WHCM class.
	//		2) That their interface numbers will be assigned contiguously.

	TInt if_number = WHCM_int_no + 1;	// for counting interface numbers
	TUint8 union_len = 4;				// for holding the length of the union descriptor

	// Iterate through the class controllers
	CUsbClassControllerIterator *iterator = Owner().UccnGetClassControllerIteratorL();

	iterator->Seek(this);

	while(    (iterator->Next() != KErrNotFound)
			&& (iterator->Current()->StartupPriority() >= StartupPriority()) )
		{
		// Found another class in the union. Add it to our list.
		TUsbDescriptor desc_info;
		iterator->Current()->GetDescriptorInfo(desc_info);
		for (TInt i=0; i<desc_info.iNumInterfaces; i++)
			{
			desc.Append(if_number++);
			union_len++;
			}
		}
    delete iterator;
	// We have added to the Union Functional Descriptor.
	// So we need to insert the new length into it.
	desc[10] = union_len;

	// Register the whole class-specific interface block
    LEAVEIFERRORL(iLdd.SetCSInterfaceDescriptorBlock(0, desc));	
	}