/*

* 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 <e32std.h>

#include <e32base.h>

#include <e32svr.h>

#include <c32comm.h>

#include "CdcControlInterface.h"

#include "CdcControlInterfaceReader.h"

#include "ClassDescriptor.h"

#include "CdcAcmClass.h"

#include "AcmPanic.h"

#include "AcmUtils.h"

CCdcControlInterface::CCdcControlInterface(const TUint8 aProtocolNum, const TDesC16& aIfcName)

/**

 * Constructor using interface name.

 * @param aProtocolNum Contains the Table 17 protocol number.

 * @param aIfcName contains the interface name

 */

 :	CCdcInterfaceBase(aIfcName), 

	iSerialState(0xFFFF),

	iProtocolNum(aProtocolNum)

	{

	}

CCdcControlInterface* CCdcControlInterface::NewL(CCdcAcmClass& aParent, const TUint8 aProtocolNum, const TDesC16& aIfcName)

/**

 * Create a new CCDCCommClass object and construct it using interface name

 * This call will return an object with a valid USB configuration

 *

 * @param aParent Pointer to the Port using this object

 * @param aProtocolNum contains the Table 17 protocol number.

 * @param aIfcName Contains the interface name

 * @return A pointer to the new object

 */

	{

	CCdcControlInterface* self = new(ELeave) CCdcControlInterface(aProtocolNum, aIfcName);

	CleanupStack::PushL(self);

	self->ConstructL(aParent);

	CLEANUPSTACK_POP(self);

	return self;

	}

void CCdcControlInterface::ConstructL(CCdcAcmClass& aParent)

/**

 * 2nd-phase construction.

 * This call registers the object with the USB device driver

 *

 * @param aParent The ACM class.

 */

	{

	BaseConstructL();

	iReader  = CCdcControlInterfaceReader::NewL(aParent, iLdd);

	}

TInt CCdcControlInterface::SetUpInterface()

/**

 * Set up the interface for use. This involves finding a "Interrupt IN" 

 * endpoint and, if found, configuring the interface.

 */

	{

	TUsbDeviceCaps dCaps;

	TInt ret = iLdd.DeviceCaps(dCaps);

	if ( ret )

		{

		return ret;

		}

	const TUint KRequiredNumberOfEndpoints = 1; // in addition to endpoint 0.

	const TUint totalEndpoints = static_cast<TUint>(dCaps().iTotalEndpoints);

	if ( totalEndpoints < KRequiredNumberOfEndpoints )

		{

		return KErrGeneral;

		}

	// Endpoints

	TUsbcEndpointData data[KUsbcMaxEndpoints];

	TPtr8 dataptr(reinterpret_cast<TUint8*>(data), sizeof(data), sizeof(data));

	ret = iLdd.EndpointCaps(dataptr);

	if ( ret )

		{

		return ret;

		}

	// Set the active interface

	TUsbcInterfaceInfoBuf ifc;

	TBool epFound = EFalse;

	for ( TUint i = 0 ; i < totalEndpoints ; i++ )

		{

		const TUsbcEndpointCaps* caps = &data[i].iCaps;

		if (data[i].iInUse)

			{

			continue;

			}

		if ((caps->iTypesAndDir & (KUsbEpTypeInterrupt | KUsbEpDirIn)) == 

			(KUsbEpTypeInterrupt | KUsbEpDirIn))

			{

			// EEndpoint1 is interrupt endpoint

			ifc().iEndpointData[0].iType  = KUsbEpTypeInterrupt;

			ifc().iEndpointData[0].iDir   = KUsbEpDirIn; 

			//get the max packet size it can potentially support

			//it's possible that it can support Isoch (1023) which is greater

			//than max for Int at 64

			TInt maxSize = Min(caps->MaxPacketSize(), KMaxPacketTypeInterrupt);

			ifc().iEndpointData[0].iSize  = maxSize;

			ifc().iEndpointData[0].iInterval = KPollInterval; 

			epFound = ETrue;

			break;

			}

		}

	if ( !epFound )

		{

		return KErrGeneral;

		}

	ifc().iString = &iIfcName;

	ifc().iTotalEndpointsUsed = KRequiredNumberOfEndpoints;

	// Codes taken from USBCDC 1.1.

	ifc().iClass.iClassNum	  = 0x02; // Table 15- Communication Interface Class

	ifc().iClass.iSubClassNum = 0x02; // Table 16- Abstract Control Model

	ifc().iClass.iProtocolNum = iProtocolNum; // Table 17

	// Zero effectively indicates that alternate interfaces are not used.

	ret = iLdd.SetInterface(0, ifc);

	return ret;

	}

TInt CCdcControlInterface::SetupClassSpecificDescriptor(

							TUint8 aDataInterfaceNumber)

/**

 * Setup the Class Descriptors

 *

 * @param aDataInterfaceNumber The interface number of the data class

 * @return Error.

 */

	{

	TInt res;

	TUsbCsClassDescriptor descriptor;

	// Header Functional Descriptor- table 26

	descriptor.iHdrSize 		 = 0x05; // bFunctionLength

	descriptor.iHdrType 		 = 0x24; // bDescriptorType- CS_INTERFACE

	descriptor.iHdrSubType		 = 0x00; // Table 25- Header FD

	descriptor.iHdrBcdCDC		 = 0x0110; // release number

	// Abstract Control Management Functional Descriptor- table 28

	descriptor.iAcmSize 		 = 0x04; // bFunctionLength

	descriptor.iAcmType 		 = 0x24; // bDescriptorType- CS_INTERFACE

	descriptor.iAcmSubType		 = 0x02; // Table 25- ACM FD

	descriptor.iAcmCapabilities  = 0x0f; // capabilities- all

	// Union functional descriptor- table 33

	descriptor.iUnSize			 = 0x05; // bFunctionLength

	descriptor.iUnType			 = 0x24; // bDescriptorType- CS_INTERFACE

	descriptor.iUnSubType		 = 0x06; // Table 25- Union FD

	// Set the control interface as the master...

	res = GetInterfaceNumber(descriptor.iUnMasterInterface);

	// ... and the data interface as the slave.

	descriptor.iUnSlaveInterface = aDataInterfaceNumber;

#if defined(DISABLE_ACM_CF_COUNTRY_SETTING)

	// no functional descriptor needed

#elif defined(ENABLE_ACM_CF_COUNTRY_SETTING)

	// CDC Country Selection Functional Descriptor

	descriptor.iCsSize			 = 0x04 + (0x02*KUsbCommNumCountries); // bFunctionLength

	descriptor.iCsType			 = 0x24; // bDescriptorType- CS_INTERFACE

	descriptor.iCsSubType		 = 0x07; // Table 25- Country Selection FD

	descriptor.iCsRelDate		 = 0x07; // Release date of ISO3166 country codes.

	descriptor.iCsCountryCode[0] = KUsbCommCountryCode0; // Country cide

#endif

	if ( res )

		{

		return res;

		}

	res = iLdd.SetCSInterfaceDescriptorBlock(0, descriptor.Des());

	if ( res )

		{

		return res;

		}

	return KErrNone;

	}

CCdcControlInterface::~CCdcControlInterface()

/**

 * Destructor

 */

	{

	delete iReader;

	}

/**

 * Special data object used to send a NETWORK_CONNECTION notification

 * up to the (USB) Host, using whatever size is available on the

 * control endpoint (derived in the driver below)

 */

const TUint KUSBNotificationNetworkConnectionSize = 8;

NONSHARABLE_CLASS(TUSBNotificationNetworkConnection)

	{

public:

	TUint8	bmRequestType;	///< Request type

	TUint8	bNotification;	///< Notification number

	TUint16 wValue; 		///< Notification value

	TUint16 wIndex; 		///< Notification index

	TUint16 wLength;		///< Notification length

public:

	TDes8&	PackBuffer();

private:

	TBuf8<KUSBNotificationNetworkConnectionSize> iBuffer;

	};

TDes8& TUSBNotificationNetworkConnection::PackBuffer()

/**

 * This function packs the TUSBNotificationSerialState class into a 

 * byte buffer with the correct byte alignment for transmission on 

 * the little-endian USB bus.

 */

	{

	iBuffer.SetLength(KUSBNotificationNetworkConnectionSize);

	iBuffer[0] = bmRequestType;

	iBuffer[1] = bNotification;

	iBuffer[2] = static_cast<TUint8>( wValue	& 0x00ff);

	iBuffer[3] = static_cast<TUint8>((wValue	& 0xff00) >> 8);

	iBuffer[4] = static_cast<TUint8>( wIndex	& 0x00ff);

	iBuffer[5] = static_cast<TUint8>((wIndex	& 0xff00) >> 8);

	iBuffer[6] = static_cast<TUint8>( wLength & 0x00ff);

	iBuffer[7] = static_cast<TUint8>((wLength & 0xff00) >> 8);

	return iBuffer;

	}

TInt CCdcControlInterface::SendNetworkConnection(TBool aValue)

/**

 * Sends a Network Connection message to the host.

 * Note that this function has not been tested. It is included for 

 * completeness as it may need to be used in modem (DCE) mode. However, it is 

 * unclear how a C32 client would indicate to the CSY that a network 

 * connection had been established.

 *

 * @param aValue	ETrue if Network Connected

 * @return Error.

 */

	{

	// form the message and prime it down to the interrupt handler

	// (that is 'interrupt' in the USB sense)

	// Note that this does not need to be aware of endian-ness, this

	// is taken care of in the PackBuffer() function.

	TUSBNotificationNetworkConnection notification;

	notification.bmRequestType = 0xA1;

	notification.bNotification = 0x00; // NETWORK_CONNECTION

	notification.wValue 	   = static_cast<TUint16>((aValue)?0x0001:0x0000); //1 - connected, 0 - disconnected

	notification.wIndex 	   = static_cast<TUint16>((aValue)?0x0001:0x0000);

	notification.wLength       = 0x00;

	TInt ret = WriteData(EEndpoint1, 

		notification.PackBuffer(), 

		notification.PackBuffer().Length());

	return ret;

	}

/**

 * Special data object used to send a SERIAL_STATE notification

 * up to the (USB) Host, using whatever size is available on the

 * control endpoint (derived in the driver below)

 */

const TUint KUSBNotificationSerialStateSize = 10;

NONSHARABLE_CLASS(TUSBNotificationSerialState)

	{

public:

	TUint8	bmRequestType;	///< Request type

	TUint8	bNotification;	///< Notification number

	TUint16 wValue; 		///< Notification value

	TUint16 wIndex; 		///< Notification index

	TUint16 wLength;		///< Notification length

	TUint16 wData;			///< 2-byte data payload

public:

	TDes8&	PackBuffer();

private:

	TBuf8<KUSBNotificationSerialStateSize> iBuffer;

	};

TDes8& TUSBNotificationSerialState::PackBuffer()

/**

 * This function packs the TUSBNotificationSerialState class into a 

 * byte buffer with the correct byte alignment for transmission on 

 * the little-endian USB bus.

 */

	{

	iBuffer.SetLength(KUSBNotificationSerialStateSize);

	iBuffer[0] = bmRequestType;

	iBuffer[1] = bNotification;

	iBuffer[2] = static_cast<TUint8>( wValue	& 0x00ff);

	iBuffer[3] = static_cast<TUint8>((wValue	& 0xff00) >> 8);

	iBuffer[4] = static_cast<TUint8>( wIndex	& 0x00ff);

	iBuffer[5] = static_cast<TUint8>((wIndex	& 0xff00) >> 8);

	iBuffer[6] = static_cast<TUint8>( wLength & 0x00ff);

	iBuffer[7] = static_cast<TUint8>((wLength & 0xff00) >> 8);

	iBuffer[8] = static_cast<TUint8>( wData & 0x00ff);

	iBuffer[9] = static_cast<TUint8>((wData & 0xff00) >> 8);

	return iBuffer;

	}

TInt CCdcControlInterface::SendSerialState(TBool aOverRun, 

									 TBool aParity, 

									 TBool aFraming, 

									 TBool aRing,

									 TBool aBreak, 

									 TBool aTxCarrier, 

									 TBool aRxCarrier)

/**

 * Sends a Serial State message to the host

 * 

 * @param aOverRun True if data discarded due to overrun

 * @param aParity True if a parity error has occured

 * @param aFraming True if a framing error has occured

 * @param aRing True if the device is Ringing

 * @param aBreak True if the device is detecting a break condition

 * @param aTxCarrier True if the transmit carrier is present

 * @param aRxCarrier True if the receive carrier is present

 * @return Error.

 */

	{

	// First work out what might need to be sent by assembling the bits into 

	// the correct places. See CDC spec table 69 (UART state bitmap values).

	TUint16 data = static_cast<TUint16>

					(

						(aRxCarrier 	) |

						(aTxCarrier << 1) |

						(aBreak 	<< 2) |

						(aRing		<< 3) |

						(aFraming	<< 4) |

						(aParity	<< 5) |

						(aOverRun	<< 6)

					);

	// now check to see if this has created a different state than

	// last time it was sent, if it is the same, don't bother to

	// send it off.

	if ( data == iSerialState )

		{

		return KErrNone;

		}

	// state is different, store local to the class object ready for

	// testing next time through

	iSerialState = data;

	// now form the message and prime it down to the interrupt handler

	// (that is 'interrupt' in the USB sense)

	// Note that this does not need to be aware of endian-ness, this

	// is taken care of in the PackBuffer() function.

	TUSBNotificationSerialState notification;

	notification.bmRequestType = 0xA1;

	notification.bNotification = 0x20; // SERIAL_STATE

	notification.wValue 	   = 0x0000;

	notification.wIndex 	   = 0x0000;

	notification.wLength	   = 0x0002;

	notification.wData		   = data;

	TInt ret = WriteData(	EEndpoint1, 

							notification.PackBuffer(), 

							notification.PackBuffer().Length());

	return ret;

	}

TInt CCdcControlInterface::WriteData(TEndpointNumber aEndPoint, 

							   TDes8& aDes, 

							   TInt aLength)

/**

 *

 *

 * @param aEndPoint

 * @param aDes

 * @param aLength

 */

	{