$suite Log

# HG changeset patch # User Dremov Kirill (Nokia-D-MSW/Tampere) # Date 1265068979 -7200 # Node ID c9bc50fca66e122885775c975a98300a943e9870 Revision: 201001 Kit: 201005 diff -r 000000000000 -r c9bc50fca66e group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/group/bld.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,24 @@ +/* +* Copyright (c) 2006 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: Build information file for project ?myapp +* +*/ + + +PRJ_PLATFORMS + + +/* include subsystems build info */ +#include "../usb_plat/group/bld.inf" +#include "../usbextension/group/bld.inf" diff -r 000000000000 -r c9bc50fca66e layers.sysdef.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/layers.sysdef.xml Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,14 @@ + + +]> + + + + + + + + + + diff -r 000000000000 -r c9bc50fca66e package_definition.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/package_definition.xml Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff -r 000000000000 -r c9bc50fca66e sysdef_1_4_0.dtd --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sysdef_1_4_0.dtd Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,86 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -r 000000000000 -r c9bc50fca66e usb_info/usb_metadata/usb_metadata.mrp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usb_info/usb_metadata/usb_metadata.mrp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,6 @@ +component usb_metadata +source \sf\os\usb\usb_info\usb_metadata +source \sf\os\usb\package_definition.xml +source \sf\os\usb\distribution.policy.s60 +notes_source \component_defs\release.src +ipr T diff -r 000000000000 -r c9bc50fca66e usb_plat/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usb_plat/group/bld.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,30 @@ +/* +* Copyright (c) 2007 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: Build information file +* +*/ + + +PRJ_PLATFORMS +DEFAULT + +#include "../usb_audio_stream_plugin_api/group/bld.inf" + +PRJ_EXPORTS + +PRJ_MMPFILES + +PRJ_TESTMMPFILES + +PRJ_TESTEXPORTS diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbclassandmgrdocs/USBDI-Unit Test Design.EAP Binary file usbmgmt/usbclassandmgrdocs/USBDI-Unit Test Design.EAP has changed diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbclassandmgrdocs/USB_Control_App_UML_Diagrams.eap Binary file usbmgmt/usbclassandmgrdocs/USB_Control_App_UML_Diagrams.eap has changed diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbclassandmgrdocs/USB_FDF_Model.EAP Binary file usbmgmt/usbclassandmgrdocs/USB_FDF_Model.EAP has changed diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbclassandmgrdocs/USB_Host_and_OTG_Test_Harness_Design.eap Binary file usbmgmt/usbclassandmgrdocs/USB_Host_and_OTG_Test_Harness_Design.eap has changed diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbclassandmgrdocs/USB_MSMM_Design.eap Binary file usbmgmt/usbclassandmgrdocs/USB_MSMM_Design.eap has changed diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbclassandmgrdocs/usb_documentation.history.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbclassandmgrdocs/usb_documentation.history.xml Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,13 @@ + + + + Documentation for USB. + + + + Project mgt documents removed + + + + + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbclassandmgrdocs/usb_documentation.mrp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbclassandmgrdocs/usb_documentation.mrp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,27 @@ +# 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: +# +# +# + + +component usb_documentation + +source \sf\os\usb\usbmgmt\usbclassandmgrdocs\ + +notes_source \component_defs\release.src + + +ipr D + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/conf/usbmanager.confml Binary file usbmgmt/usbmgr/conf/usbmanager.confml has changed diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/bld.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,19 @@ +/* +* Copyright (c) 2007-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 "classcontroller/group/bld.inf" +#include "classdrivers/bld.inf" diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classcontroller/BWINS/usbclasscontrolleru.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classcontroller/BWINS/usbclasscontrolleru.def Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,18 @@ +EXPORTS + ??0CUsbClassControllerBase@@IAE@AAVMUsbClassControllerNotify@@H@Z @ 1 NONAME ; protected: __thiscall CUsbClassControllerBase::CUsbClassControllerBase(class MUsbClassControllerNotify &,int) + ??0CUsbClassControllerIterator@@QAE@AAV?$RPointerArray@VCUsbClassControllerBase@@@@@Z @ 2 NONAME ; public: __thiscall CUsbClassControllerIterator::CUsbClassControllerIterator(class RPointerArray &) + ??0CUsbClassControllerPlugIn@@IAE@AAVMUsbClassControllerNotify@@H@Z @ 3 NONAME ; protected: __thiscall CUsbClassControllerPlugIn::CUsbClassControllerPlugIn(class MUsbClassControllerNotify &,int) + ??1CUsbClassControllerBase@@UAE@XZ @ 4 NONAME ; public: virtual __thiscall CUsbClassControllerBase::~CUsbClassControllerBase(void) + ??1CUsbClassControllerIterator@@UAE@XZ @ 5 NONAME ; public: virtual __thiscall CUsbClassControllerIterator::~CUsbClassControllerIterator(void) + ??1CUsbClassControllerPlugIn@@UAE@XZ @ 6 NONAME ; public: virtual __thiscall CUsbClassControllerPlugIn::~CUsbClassControllerPlugIn(void) + ?Compare@CUsbClassControllerBase@@SAHABV1@0@Z @ 7 NONAME ; public: static int __cdecl CUsbClassControllerBase::Compare(class CUsbClassControllerBase const &,class CUsbClassControllerBase const &) + ?Current@CUsbClassControllerIterator@@QAEPAVCUsbClassControllerBase@@XZ @ 8 NONAME ; public: class CUsbClassControllerBase * __thiscall CUsbClassControllerIterator::Current(void) + ?First@CUsbClassControllerIterator@@QAEHXZ @ 9 NONAME ; public: int __thiscall CUsbClassControllerIterator::First(void) + ?NewL@CUsbClassControllerPlugIn@@SAPAV1@VTUid@@AAVMUsbClassControllerNotify@@@Z @ 10 NONAME ; public: static class CUsbClassControllerPlugIn * __cdecl CUsbClassControllerPlugIn::NewL(class TUid,class MUsbClassControllerNotify &) + ?Next@CUsbClassControllerIterator@@QAEHXZ @ 11 NONAME ; public: int __thiscall CUsbClassControllerIterator::Next(void) + ?Owner@CUsbClassControllerBase@@QBEAAVMUsbClassControllerNotify@@XZ @ 12 NONAME ; public: class MUsbClassControllerNotify & __thiscall CUsbClassControllerBase::Owner(void)const + ?Previous@CUsbClassControllerIterator@@QAEHXZ @ 13 NONAME ; public: int __thiscall CUsbClassControllerIterator::Previous(void) + ?Seek@CUsbClassControllerIterator@@QAEHPAVCUsbClassControllerBase@@@Z @ 14 NONAME ; public: int __thiscall CUsbClassControllerIterator::Seek(class CUsbClassControllerBase *) + ?StartupPriority@CUsbClassControllerBase@@QBEHXZ @ 15 NONAME ; public: int __thiscall CUsbClassControllerBase::StartupPriority(void)const + ?State@CUsbClassControllerBase@@QBE?AW4TUsbServiceState@@XZ @ 16 NONAME ; public: enum TUsbServiceState __thiscall CUsbClassControllerBase::State(void)const + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classcontroller/EABI/usbclasscontrollerU.DEF --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classcontroller/EABI/usbclasscontrollerU.DEF Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,29 @@ +EXPORTS + _ZN23CUsbClassControllerBase7CompareERKS_S1_ @ 1 NONAME + _ZN23CUsbClassControllerBaseC2ER25MUsbClassControllerNotifyi @ 2 NONAME + _ZN23CUsbClassControllerBaseD0Ev @ 3 NONAME + _ZN23CUsbClassControllerBaseD1Ev @ 4 NONAME + _ZN23CUsbClassControllerBaseD2Ev @ 5 NONAME + _ZN25CUsbClassControllerPlugIn4NewLE4TUidR25MUsbClassControllerNotify @ 6 NONAME + _ZN25CUsbClassControllerPlugInC2ER25MUsbClassControllerNotifyi @ 7 NONAME + _ZN25CUsbClassControllerPlugInD0Ev @ 8 NONAME + _ZN25CUsbClassControllerPlugInD1Ev @ 9 NONAME + _ZN25CUsbClassControllerPlugInD2Ev @ 10 NONAME + _ZN27CUsbClassControllerIterator4NextEv @ 11 NONAME + _ZN27CUsbClassControllerIterator4SeekEP23CUsbClassControllerBase @ 12 NONAME + _ZN27CUsbClassControllerIterator5FirstEv @ 13 NONAME + _ZN27CUsbClassControllerIterator7CurrentEv @ 14 NONAME + _ZN27CUsbClassControllerIterator8PreviousEv @ 15 NONAME + _ZN27CUsbClassControllerIteratorC1ER13RPointerArrayI23CUsbClassControllerBaseE @ 16 NONAME + _ZN27CUsbClassControllerIteratorC2ER13RPointerArrayI23CUsbClassControllerBaseE @ 17 NONAME + _ZN27CUsbClassControllerIteratorD0Ev @ 18 NONAME + _ZN27CUsbClassControllerIteratorD1Ev @ 19 NONAME + _ZN27CUsbClassControllerIteratorD2Ev @ 20 NONAME + _ZNK23CUsbClassControllerBase15StartupPriorityEv @ 21 NONAME + _ZNK23CUsbClassControllerBase5OwnerEv @ 22 NONAME + _ZNK23CUsbClassControllerBase5StateEv @ 23 NONAME + _ZTI23CUsbClassControllerBase @ 24 NONAME ; ## + _ZTI25CUsbClassControllerPlugIn @ 25 NONAME ; ## + _ZTV23CUsbClassControllerBase @ 26 NONAME ; ## + _ZTV25CUsbClassControllerPlugIn @ 27 NONAME ; ## + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classcontroller/SRC/CUsbClassControllerBase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classcontroller/SRC/CUsbClassControllerBase.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,93 @@ +/* +* 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 Controller Framework. +* All USB classes to be managed by UsbMan must derive +* from this class. +* +*/ + +/** + @file +*/ + +#include +#include + + +/** + * Constructor. + * + * @param aOwner Owner and manager of this object + * @param aStartupPriority The priority of the Class Controller (the + * priorities of all present Class Controllers determines the order in which + * they are started). + */ +EXPORT_C CUsbClassControllerBase::CUsbClassControllerBase( + MUsbClassControllerNotify& aOwner, TInt aStartupPriority) + : CActive(EPriorityStandard), iStartupPriority(aStartupPriority), + iState(EUsbServiceIdle), iOwner(aOwner) + { + CActiveScheduler::Add(this); + } + +/** + * Destructor. + */ +EXPORT_C CUsbClassControllerBase::~CUsbClassControllerBase() + { + } + +/** + * Fetch the owner of the USB class controller. + * + * @return The owner of the USB class controller + */ +EXPORT_C MUsbClassControllerNotify& CUsbClassControllerBase::Owner() const + { + return iOwner; + } + +/** + * Get the state of this USB class controller. + * + * @return The state of this USB class controller + */ +EXPORT_C TUsbServiceState CUsbClassControllerBase::State() const + { + return iState; + } + +/** + * Get the startup priority of this USB class controller. + * + * @return The startup priority of this USB class controller + */ +EXPORT_C TInt CUsbClassControllerBase::StartupPriority() const + { + return iStartupPriority; + } + +EXPORT_C TInt CUsbClassControllerBase::Compare(const CUsbClassControllerBase& aFirst, + const CUsbClassControllerBase& aSecond) + { + if (aFirst.StartupPriority() < aSecond.StartupPriority()) { + return -1; + } + else if (aFirst.StartupPriority() > aSecond.StartupPriority()) { + return 1; + } + return 0; + } + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classcontroller/SRC/CUsbClassControllerIterator.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classcontroller/SRC/CUsbClassControllerIterator.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,139 @@ +/* +* 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 a helper class for iterating over CUsbClassControllerBase +* objects. +* +*/ + +/** + @file +*/ + + +#include +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "USBSVR"); +#endif + +// Panic category only used in debug builds +#ifdef _DEBUG +_LIT( KUsbCcIteratorPanicCategory, "UsbCcIterator" ); +#endif + +/** + * Panic codes for the USB Class Controller Iterator. + */ +enum TUsbCcIteratorPanic + { + /** Class controller index is out of range */ + EIndexOutOfRange = 0, + }; + + +/** + * Constructor. Initialises the internal reference to a class array. + */ +EXPORT_C CUsbClassControllerIterator::CUsbClassControllerIterator( + RPointerArray& aClassControllerArray) + : iClassControllerArray(aClassControllerArray) +{ +} + +/** + * Destructor. + */ + EXPORT_C CUsbClassControllerIterator::~CUsbClassControllerIterator() + { + } + +/** + * Sets the iterator to the first USB class. + * + * @return KErrNotFound if there are no USB classes. + */ + EXPORT_C TInt CUsbClassControllerIterator::First() + { + if (iClassControllerArray.Count() > 0) + { + iClassControllerIndex = 0; + return KErrNone; + } + return KErrNotFound; + } + +/** + * Sets the iterator to the next USB class. + * + * @return KErrNotFound if there are no more classes + */ +EXPORT_C TInt CUsbClassControllerIterator::Next() + { + if (iClassControllerIndex < (iClassControllerArray.Count()-1)) + { + iClassControllerIndex++; + return KErrNone; + } + return KErrNotFound; + } + +/** + * Sets the iterator to the previous USB class. + * + * @return KErrNotFound if there are no more classes + */ +EXPORT_C TInt CUsbClassControllerIterator::Previous() + { + if (iClassControllerIndex > 0) + { + iClassControllerIndex--; + return KErrNone; + } + return KErrNotFound; + } + +/** + * Finds the specified class in the list of USB classes. + * + * @return KErrNotFound if the class isn't in the array + */ +EXPORT_C TInt CUsbClassControllerIterator::Seek( + CUsbClassControllerBase* aClassController) + { + TInt ret = iClassControllerArray.Find(aClassController); + + if (ret != KErrNotFound) + iClassControllerIndex = ret; + else + return KErrNotFound; + + return KErrNone; + } + +/** + * Gets the current class the iterator's pointing to. + * + * @return The current class the iterator refers to + */ +EXPORT_C CUsbClassControllerBase* CUsbClassControllerIterator::Current() + { + __ASSERT_DEBUG((iClassControllerIndex >= 0) && + (iClassControllerIndex < iClassControllerArray.Count()), + _USB_PANIC(KUsbCcIteratorPanicCategory, EIndexOutOfRange)); + + return iClassControllerArray[iClassControllerIndex]; + } + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classcontroller/SRC/CUsbClassControllerPlugIn.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classcontroller/SRC/CUsbClassControllerPlugIn.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,68 @@ +/* +* 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 Controller Framework. +* All USB classes to be managed by UsbMan must derive +* from this class. +* +*/ + +/** + @file +*/ + +#include +#include +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "USBSVR"); +#endif + +/** + * Constructor. + * + */ + +EXPORT_C CUsbClassControllerPlugIn::CUsbClassControllerPlugIn( + MUsbClassControllerNotify& aOwner, TInt aStartupPriority) + : CUsbClassControllerBase(aOwner, aStartupPriority) + { + } + +/** + * Constructs a CUsbClassControllerPlugIn object. + * + * @return A new CUsbClassControllerPlugIn object + */ + +EXPORT_C CUsbClassControllerPlugIn* CUsbClassControllerPlugIn::NewL(TUid aImplementationId, + MUsbClassControllerNotify& aOwner) + { + LOG_STATIC_FUNC_ENTRY + + return (reinterpret_cast(REComSession::CreateImplementationL + (aImplementationId, _FOFF(CUsbClassControllerPlugIn, iPrivateEComUID), + (TAny*) &aOwner))); + } + + +/** + * Destructor. + */ +EXPORT_C CUsbClassControllerPlugIn::~CUsbClassControllerPlugIn() + { + REComSession::DestroyedImplementation(iPrivateEComUID); + } + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classcontroller/group/UsbClassController.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classcontroller/group/UsbClassController.mmp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,41 @@ +/* +* 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: +* usbclassconstroller.mmp +* USBClassController.dll USB Class Controller Plugin Framework +* +*/ + +/** + @file +*/ + + +target usbclasscontroller.dll //Recommended unpaged +CAPABILITY CommDD NetworkControl NetworkServices LocalServices ProtServ +targettype dll +uid 0x1000008d 0x101fe1da +VENDORID 0x70000001 + +sourcepath ../SRC +source CUsbClassControllerBase.cpp +source CUsbClassControllerPlugIn.cpp +source CUsbClassControllerIterator.cpp + +OS_LAYER_SYSTEMINCLUDE_SYMBIAN + +library euser.lib +library ecom.lib + +#include diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classcontroller/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classcontroller/group/bld.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,25 @@ +/* +* Copyright (c) 2007-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: +* +*/ + +PRJ_EXPORTS +../public/CUsbClassControllerBase.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(cusbclasscontrollerbase.h) +../public/CUsbClassControllerPlugIn.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(cusbclasscontrollerplugin.h) +../public/CUsbClassControllerIterator.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(cusbclasscontrolleriterator.h) +../public/MUsbClassControllerNotify.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(musbclasscontrollernotify.h) + +PRJ_MMPFILES +UsbClassController.mmp // Base DLL for CC functionality diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classcontroller/public/CUsbClassControllerBase.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classcontroller/public/CUsbClassControllerBase.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,139 @@ +/* +* 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. +* All USB classes to be managed by UsbMan must derive +* from this class. +* +*/ + +/** + @file +*/ + +#ifndef __CUSBCLASSCONTROLLERBASE_H__ +#define __CUSBCLASSCONTROLLERBASE_H__ + +#include +#include + +class MUsbClassControllerNotify; +class TUsbDescriptor; + +class CUsbClassControllerBase : public CActive +/** Base class for Class Controllers. + + @publishedPartner + @released + */ + { +public: + /** Owner + @return The owner of the class controller. + */ + IMPORT_C MUsbClassControllerNotify& Owner() const; + + /** State + @return The service state. + */ + IMPORT_C TUsbServiceState State() const; + + /** StartupPriority + @return The relative priority of this class controller. + */ + IMPORT_C TInt StartupPriority() const; + + /** Compare + Static function to compare two class controllers on the basis of their + startup priorities. + @param aFirst First class controller. + @param aSecond Second class controller. + @return Result of comparison of two class controllers. + */ + IMPORT_C static TInt Compare(const CUsbClassControllerBase& aFirst, + const CUsbClassControllerBase& aSecond); + +public: // Functions derived from CActive to be implemented by derived classes. + /** RunL + Framework function. Class controllers are Active Objects, and may if + relevant use that to register interfaces asynchronously. + */ + virtual void RunL() = 0; + + /** DoCancel + Framework function. + */ + virtual void DoCancel() = 0; + + /** RunError + @param aError The error with which RunL left. + @return Error. + */ + virtual TInt RunError(TInt aError) = 0; + +public: + /** Destructor + */ + IMPORT_C virtual ~CUsbClassControllerBase(); + +public: + /** Start + Called by the server to get this class controller to register its + interfaces. + @param aStatus TRequestStatus to signal completion of the request. + */ + virtual void Start(TRequestStatus& aStatus) = 0; + + /** Stop + Called by the server to get this class controller to deregister its + interfaces. + @param aStatus TRequestStatus to signal completion of the request. + */ + virtual void Stop(TRequestStatus& aStatus) = 0; + + /** GetDescriptorInfo + Returns information on the class controller's descriptors. + @param aDescriptorInfo Structure to return information in. + */ + virtual void GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const = 0; + +protected: + /** Constructor + @param aOwner Owner. + @param aStartupPriority Relative startup priority of this class controller. + */ + IMPORT_C CUsbClassControllerBase(MUsbClassControllerNotify& aOwner, TInt aStartupPriority); + +protected: + /** + The relative priority of this class controller. The class controllers + are sorted using their priorities to determine what order to start + them in. + */ + const TInt iStartupPriority; + + /** + The current service state. This must be kept up-to-date depending on + whether this class controller's interfaces are registered or not. + */ + TUsbServiceState iState; + + /** + Owner. + */ + MUsbClassControllerNotify& iOwner; + }; + +#endif //__CUSBCLASSCONTROLLERBASE_H__ + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classcontroller/public/CUsbClassControllerIterator.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classcontroller/public/CUsbClassControllerIterator.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,92 @@ +/* +* 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: +* Defines a helper class used to iterate over a set of USB classes. +* +*/ + +/** + @file +*/ + +#ifndef __CUSBCLASSCONTROLLERITERATOR_H__ +#define __CUSBCLASSCONTROLLERITERATOR_H__ + +#include + +class CUsbClassControllerBase; + +/** This class is used by CUsbDevice and potentially + * CUsbClassControllerBase-derived classes to iterate over a collection of + * CUsbClassControllerBase objects. + + @publishedPartner + @released + */ +NONSHARABLE_CLASS(CUsbClassControllerIterator) : public CBase + { +public: + /** Constructor + @param aClassControllerArray Array of class controllers. + */ + IMPORT_C CUsbClassControllerIterator(RPointerArray& aClassControllerArray); + + /** Destructor. + */ + IMPORT_C ~CUsbClassControllerIterator(); + + /** First + Sets the iterator to the first class controller. + @return Error. + */ + IMPORT_C TInt First(); + + /** Next + Sets the iterator to the next class controller. + @return Error. + */ + IMPORT_C TInt Next(); + + /** Previous + Sets the iterator to the previous class controller. + @return Error. + */ + IMPORT_C TInt Previous(); + + /** Seek + Sets the current class controller to that given, if it's in the array. + @param aClassController The class controller we want to find. + @return Error. + */ + IMPORT_C TInt Seek(CUsbClassControllerBase* aClassController); + + /** Current + @return The current class controller. Does not return ownership. + */ + IMPORT_C CUsbClassControllerBase* Current(); + +private: + /** + The array of class controllers. + */ + RPointerArray& iClassControllerArray; + + /** + Index of current class controller. + */ + TInt iClassControllerIndex; + }; + + +#endif //__CUSBCLASSCONTROLLERITERATOR_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classcontroller/public/CUsbClassControllerPlugIn.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classcontroller/public/CUsbClassControllerPlugIn.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,71 @@ +/* +* 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. +* All USB classes to be managed by UsbMan must derive +* from this class. +* +*/ + +/** + @file +*/ + +#ifndef CUSBCLASSCONTROLLERPLUGIN_H__ +#define CUSBCLASSCONTROLLERPLUGIN_H__ + +#include + + +class MUsbClassControllerNotify; + +class CUsbClassControllerPlugIn : public CUsbClassControllerBase +/** Base class for dynamic Class Controllers, implemented as ECOM plugins. + + @publishedPartner + @released + */ + { +public: + /** Factory function + @param aImplementationId The UID of this implementation. + @param aOwner Interface to talk to the server. + @return Ownership of a new CUsbClassControllerPlugIn. + */ + IMPORT_C static CUsbClassControllerPlugIn* NewL(TUid aImplementationId, + MUsbClassControllerNotify& aOwner); + + /** Destructor + */ + IMPORT_C virtual ~CUsbClassControllerPlugIn(); + + + +protected: + /** Constructor + @param aOwner Interface to talk to the server. + @param aStartupPriority The relative priority of this class controller. + */ + IMPORT_C CUsbClassControllerPlugIn(MUsbClassControllerNotify& aOwner, TInt aStartupPriority); + +protected: + /** + UID given to us by ECOM when the instance is created. Used when the + instance is destroyed. + */ + TUid iPrivateEComUID; + }; + +#endif + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classcontroller/public/MUsbClassControllerNotify.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classcontroller/public/MUsbClassControllerNotify.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,63 @@ +/* +* 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: +* MClassControllerNotify.h +* Implements part of the USB Class API Framework +* This is the mixin used by the USB classes to notify UsbMan of failures, +* and to get an iterator over the set of classes UsbMan owns. +* +*/ + +/** + @file +*/ + +#ifndef __MUSBCLASSCONTROLLERNOTIFY_H__ +#define __MUSBCLASSCONTROLLERNOTIFY_H__ + +#include + +class CUsbClassControllerIterator; + +/** The MUsbClassControllerNotify class + * + * Implements part of the USB Class API Framework. + * This is the mixin used by the USB classes to notify UsbMan of any changes + * in their state. + + @publishedPartner + @released + */ +class MUsbClassControllerNotify + { +public: + /** + * Creates and returns a new iterator over USB classes. The caller takes + * ownership of this iterator. + * + * @return A new iterator + */ + virtual CUsbClassControllerIterator* + UccnGetClassControllerIteratorL() = 0; + + /** + * Called when a USB class has received an unexpected error and should be + * shut down. + * + * @param aError The error code + */ + virtual void UccnError(TInt aError) = 0; + }; +#endif + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/bld.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,19 @@ +/* +* Copyright (c) 2007-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 "classimplementation/bld.inf" +#include "classcontroller/group/bld.inf" diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/INC/CUsbACMClassController.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/INC/CUsbACMClassController.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,127 @@ +/** +* 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: +* Adheres to the UsbMan USB Class API and talks to C32 +* to manage the ACM.CSY that is used to provide a virtual +* serial port service to clients +* +* +*/ + + + +/** + @file +*/ + +#ifndef __CUSBACMCLASSCONTROLLER_H__ +#define __CUSBACMCLASSCONTROLLER_H__ + +#include +#include +#ifdef USE_ACM_REGISTRATION_PORT +#include +#else +#include +#endif +class MUsbClassControllerNotify; +class CIniFile; + +const TInt KAcmStartupPriority = 3; +const TUint KDefaultNumberOfAcmFunctions = 1; +const TInt KMaximumAcmFunctions = 15; + +const TInt KAcmNumberOfInterfacesPerAcmFunction = 2; // data and control interfaces +// The name of the ini file specifying the number of ACM functions required and optionally their interface names +_LIT(KAcmFunctionsIniFileName, "NumberOfAcmFunctions.ini"); +_LIT(KAcmConfigSection,"ACM_CONF"); +_LIT(KNumberOfAcmFunctionsKeyWord,"NumberOfAcmFunctions"); + +_LIT(KAcmSettingsSection,"ACM %d"); +_LIT(KAcmProtocolNum,"ProtocolNum"); +_LIT(KAcmControlIfcName,"ControlInterfaceName"); +_LIT(KAcmDataIfcName,"DataInterfaceName"); + +// Lengths of the various bits of the ACM descriptor. Taken from the USB +// WMCDC specification, v1.0. +const TInt KAcmInterfaceDescriptorLength = 3; +const TInt KAcmCcHeaderDescriptorLength = 5; +const TInt KAcmFunctionalDescriptorLength = 4; +const TInt KAcmCcUfdDescriptorLength = 5; +const TInt KAcmNotificationEndpointDescriptorLength = 7; +const TInt KAcmDataClassInterfaceDescriptorLength = 3; +const TInt KAcmDataClassHeaderDescriptorLength = 5; +const TInt KAcmDataClassEndpointInDescriptorLength = 7; +const TInt KAcmDataClassEndpointOutDescriptorLength = 7; + +const TInt KAcmDescriptorLength = + KAcmInterfaceDescriptorLength + + KAcmCcHeaderDescriptorLength + + KAcmFunctionalDescriptorLength + + KAcmCcUfdDescriptorLength + + KAcmNotificationEndpointDescriptorLength + + KAcmDataClassInterfaceDescriptorLength + + KAcmDataClassHeaderDescriptorLength + + KAcmDataClassEndpointInDescriptorLength + + KAcmDataClassEndpointOutDescriptorLength; + +/** + * The CUsbACMClassController class + * + * Implements the USB Class Controller API and manages the ACM.CSY + */ +NONSHARABLE_CLASS(CUsbACMClassController) : public CUsbClassControllerPlugIn + { + +public: // New functions. + static CUsbACMClassController* NewL(MUsbClassControllerNotify& aOwner); + +public: // Functions derived from CBase. + virtual ~CUsbACMClassController(); + +public: // Functions derived from CActive. + virtual void RunL(); + virtual void DoCancel(); + virtual TInt RunError(TInt aError); + +public: // Functions derived from CUsbClassControllerBase + virtual void Start(TRequestStatus& aStatus); + virtual void Stop(TRequestStatus& aStatus); + + virtual void GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const; + +protected: + CUsbACMClassController(MUsbClassControllerNotify& aOwner); + void ConstructL(); + +private: + void DoStartL(); + void ReadAcmConfigurationL(); + void DoStop(); + void ReadAcmIniDataL(CIniFile* aIniFile, TUint aCount, RBuf& aAcmControlIfcName, RBuf& aAcmDataIfcName); + +private: +#ifdef USE_ACM_REGISTRATION_PORT + RCommServ iCommServer; + RComm iComm; +#else + RAcmServer iAcmServer; +#endif + TInt iNumberOfAcmFunctions; + TFixedArray iAcmProtocolNum; + TFixedArray iAcmControlIfcName; + TFixedArray iAcmDataIfcName; + }; + +#endif //__CUSBACMCLASSCONTROLLER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/SRC/101fbf20.rss --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/SRC/101fbf20.rss Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,41 @@ +/* +* 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: +* +*/ + +#include + +RESOURCE REGISTRY_INFO theInfo + { + dll_uid = 0x101fbf20; + interfaces = + { + INTERFACE_INFO + { + interface_uid = 0x101fbf21; + implementations = + { + IMPLEMENTATION_INFO + { + implementation_uid = 0x101fbf22; + version_no = 1; + display_name = "ACM"; + default_data = ""; + opaque_data = ""; + } + }; + } + }; + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/SRC/CUsbACMClassController.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/SRC/CUsbACMClassController.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,443 @@ +/* +* 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: +* Adheres to the UsbMan USB Class Controller API and talks to C32 or ACM server +* to manage the ECACM.CSY that is used to provide a virtual serial port service +* to clients. +* +*/ + +/** + @file +*/ + +#include "CUsbACMClassController.h" +#include +#include +#include +#include "inifile.h" +#include "UsbmanInternalConstants.h" +#include +#include "acmserverconsts.h" + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ACMCC"); +#endif + + +// Panic category +_LIT( KAcmCcPanicCategory, "UsbAcmCc" ); + + +/** + * Panic codes for the USB ACM Class Controller. + */ +enum TAcmCcPanic + { + /** Start called while in an illegal state */ + EBadApiCallStart = 0, + /** Asynchronous function called (not needed, as all requests complete synchronously) */ + EUnusedFunction = 1, + /** Error reading ini file. */ + EPanicBadIniFile = 2, + /** Bad value for the iNumberOfAcmFunctions member.*/ + EPanicBadNumberOfAcmFunctions = 3, + /** Stop called while in an illegal state */ + EBadApiCallStop = 4, + }; + + +/** + * Constructs a CUsbACMClassController object + * + * @param aOwner USB Device that owns and manages the class + * + * @return A new CUsbACMClassController object + */ +CUsbACMClassController* CUsbACMClassController::NewL(MUsbClassControllerNotify& aOwner) + { + LOG_STATIC_FUNC_ENTRY + + CUsbACMClassController* self = new (ELeave) CUsbACMClassController(aOwner); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +/** + * Destructor + */ +CUsbACMClassController::~CUsbACMClassController() + { + Cancel(); + +#ifdef USE_ACM_REGISTRATION_PORT + iComm.Close(); + iCommServer.Close(); +#else + // Clean up any interface name strings + for ( TUint i = 0 ; i < KMaximumAcmFunctions ; i++ ) + { + iAcmControlIfcName[i].Close(); + iAcmDataIfcName[i].Close(); + } + iAcmServer.Close(); +#endif // USE_ACM_REGISTRATION_PORT + } + +/** + * Constructor. + * + * @param aOwner USB Device that owns and manages the class + */ +CUsbACMClassController::CUsbACMClassController( + MUsbClassControllerNotify& aOwner) + : CUsbClassControllerPlugIn(aOwner, KAcmStartupPriority), + iNumberOfAcmFunctions(KDefaultNumberOfAcmFunctions) + { + // Initialise all elements to KDefaultAcmProtocolNum. + for ( TUint ii = 0 ; ii < KMaximumAcmFunctions ; ii++ ) + { + iAcmProtocolNum[ii] = KDefaultAcmProtocolNum; + // iAcmControlIfcName[ii] and iAcmDataIfcName[ii] are already set to empty strings (RBuf); + } + } + +/** + * 2nd Phase Construction. + */ +void CUsbACMClassController::ConstructL() + { + //open ini file to find out how many acm functions are needed and read in their configuration data + ReadAcmConfigurationL(); + + // Prepare to use whichever mechanism is enabled to control bringing ACM + // functions up and down. +#ifdef USE_ACM_REGISTRATION_PORT + + LEAVEIFERRORL(iCommServer.Connect()); + LEAVEIFERRORL(iCommServer.LoadCommModule(KAcmCsyName)); + TName portName(KAcmSerialName); + portName.AppendFormat(_L("::%d"), 666); + // Open the registration port in shared mode in case other ACM CCs want to + // open it. + LEAVEIFERRORL(iComm.Open(iCommServer, portName, ECommShared)); + +#else + + LEAVEIFERRORL(iAcmServer.Connect()); + +#endif // USE_ACM_REGISTRATION_PORT + } + +/** +* Searches numberofacmfunctions.ini file for protocol number and for control and data +* interface names, leaving if any is not found. +*/ +void CUsbACMClassController::ReadAcmIniDataL(CIniFile* aIniFile, TUint aCount, RBuf& aAcmControlIfcName, RBuf& aAcmDataIfcName) + { + LOG_FUNC + + TName sectionName; + TInt protocolNum; + +#ifdef __FLOG_ACTIVE + TName acmProtocolNum(KAcmProtocolNum); + TBuf8 narrowAcmProtocolNum; + narrowAcmProtocolNum.Copy(acmProtocolNum); +#endif + LOGTEXT3(_L8("\tLooking for ACM Section %d, keyword \"%S\""), aCount+1, &narrowAcmProtocolNum); + + sectionName.Format(KAcmSettingsSection,(aCount+1)); + +#ifdef __FLOG_ACTIVE + // Set up useful narrow logging strings. + TBuf8 narrowSectionName; + narrowSectionName.Copy(sectionName); +#endif + LOGTEXT2(_L8("\t Section Name %S"), &narrowSectionName); + + if (aIniFile->FindVar(sectionName, KAcmProtocolNum(), protocolNum)) + { + LOGTEXT3(_L8("\tACM Section %d: Protocol No %d"),aCount+1, protocolNum); + iAcmProtocolNum[aCount] = static_cast(protocolNum); + } + + // Search ini file for interface names. If either of the interface names does not exist then the + // descriptors remain at zero length. This is caught in DoStartL and the descriptors defaulted. + // Using this method saves memory on storing copies of the default interface names. + TPtrC ptrControlIfcName; + if (aIniFile->FindVar(sectionName, KAcmControlIfcName(), ptrControlIfcName)) + { + TPtrC ptrDataIfcName; + if (aIniFile->FindVar(sectionName, KAcmDataIfcName(), ptrDataIfcName)) + { + // Only copy the data if both interface names are valid + aAcmControlIfcName.CreateL(ptrControlIfcName); + aAcmControlIfcName.CleanupClosePushL(); + aAcmDataIfcName.CreateL(ptrDataIfcName); + CleanupStack::Pop(&aAcmControlIfcName); + } + } + +#ifdef __FLOG_ACTIVE + // Set up useful narrow logging strings. + TName dbgControlIfcName(aAcmControlIfcName); + TBuf8 narrowControlIfcName; + narrowControlIfcName.Copy(dbgControlIfcName); + + TName dbgDataIfcName(aAcmDataIfcName); + TBuf8 narrowDataIfcName; + narrowDataIfcName.Copy(dbgDataIfcName); +#endif + LOGTEXT2(_L8("\t Control Interface Name %S"), &narrowControlIfcName); + LOGTEXT2(_L8("\t Data Interface Name %S"), &narrowDataIfcName); + } + +/** +Called when class Controller constructed +It opens a numberofacmfunctions.ini file and gets the info from there +Error behaviour: +If the ini file is not found the number of ACM functions, their protocol +settings and interface names will be the default values. +If a memory error occurs then leaves with KErrNoMemory. +If the ini file is created but the file contains invalid configuration then panic. +*/ +void CUsbACMClassController::ReadAcmConfigurationL() + { + LOG_FUNC + + // The number of ACM functions should at this point be as set in the + // constructor. + __ASSERT_DEBUG(static_cast(iNumberOfAcmFunctions) == KDefaultNumberOfAcmFunctions, + _USB_PANIC(KAcmCcPanicCategory, EPanicBadNumberOfAcmFunctions)); + + LOGTEXT3(_L("\ttrying to open file \"%S\" in directory \"%S\""), + &KAcmFunctionsIniFileName, &KUsbManPrivatePath); + + // First find the file + CIniFile* iniFile = NULL; + TRAPD (error, iniFile = CIniFile::NewL(KAcmFunctionsIniFileName, KUsbManPrivatePath)); + + if (error == KErrNotFound) + { + LOGTEXT(_L8("\tfile not found")); + } + else if (error != KErrNone) + { + LOGTEXT(_L8("\tini file was found, but couldn't be opened")); + LEAVEL(error); + } + else + { + LOGTEXT(_L8("\tOpened ini file")); + LOGTEXT3(_L("\tLooking for Section \"%S\", keyword \"%S\""), + &KAcmConfigSection, &KNumberOfAcmFunctionsKeyWord); + + CleanupStack::PushL(iniFile); + if ( !iniFile->FindVar(KAcmConfigSection(), KNumberOfAcmFunctionsKeyWord(), iNumberOfAcmFunctions) ) + { + // PANIC since this should only happen in development environment. + // The file is incorrectly written. + LOGTEXT(_L8("\tCan't find item")); + _USB_PANIC(KAcmCcPanicCategory, EPanicBadNumberOfAcmFunctions); + } + + LOGTEXT2(_L8("\tini file specifies %d ACM function(s)"), iNumberOfAcmFunctions); + + for ( TUint i = 0 ; i < iNumberOfAcmFunctions ; i++ ) + { + // Search ini file for the protocol number and interface names for + // the function, using defaults if any are not found. + // May leave with KErrNoMemory. + ReadAcmIniDataL(iniFile, i, iAcmControlIfcName[i], iAcmDataIfcName[i]); + } + CleanupStack::PopAndDestroy(iniFile); + } + } + +/** + * Called by UsbMan when it wants to start the USB ACM class. This always + * completes immediately. + * + * @param aStatus The caller's request status, filled in with an error code + */ +void CUsbACMClassController::Start(TRequestStatus& aStatus) + { + LOG_FUNC; + + // We should always be idle when this function is called (guaranteed by + // CUsbSession). + __ASSERT_DEBUG( iState == EUsbServiceIdle, _USB_PANIC(KAcmCcPanicCategory, EBadApiCallStart) ); + + TRequestStatus* reportStatus = &aStatus; + TRAPD(err, DoStartL()); + iState = (err == KErrNone) ? EUsbServiceStarted : EUsbServiceIdle; + User::RequestComplete(reportStatus, err); + } + +void CUsbACMClassController::DoStartL() + { + LOG_FUNC + + iState = EUsbServiceStarting; + +#ifdef USE_ACM_REGISTRATION_PORT + + // Create ACM functions. + TUint acmSetting; + for ( TUint i = 0 ; i < iNumberOfAcmFunctions ; i++ ) + { + // indicate the number of ACMs to create, and its protocol number (in the 3rd-lowest byte) + acmSetting = 1 | (static_cast(iAcmProtocolNum[i])<< 16); + TInt err = iComm.SetSignalsToMark(acmSetting); + if ( err != KErrNone ) + { + LOGTEXT2(_L8(" SetSignalsToMark error = %d"), err); + if (i != 0) + { + // Must clear any ACMs that have completed. + // only other than KErrNone if C32 Server fails + (void)iComm.SetSignalsToSpace(i); + } + LEAVEL(err); + } + } + +#else // use ACM server + + // Create ACM functions + for ( TInt i = 0 ; i < iNumberOfAcmFunctions ; i++ ) + { + TInt err; + // Check for zero length descriptor and default it if so + if (iAcmControlIfcName[i].Length()) + { + err = iAcmServer.CreateFunctions(1, iAcmProtocolNum[i], iAcmControlIfcName[i], iAcmDataIfcName[i]); + } + else + { + err = iAcmServer.CreateFunctions(1, iAcmProtocolNum[i], KControlIfcName, KDataIfcName); + } + + if ( err != KErrNone ) + { + LOGTEXT2(_L8("\tFailed to create ACM function. Error: %d"), err); + if (i != 0) + { + //Must clear any ACMs that have been completed + iAcmServer.DestroyFunctions(i); + LOGTEXT2(_L8("\tDestroyed %d Interfaces"), i); + } + LEAVEL(err); + } + } + +#endif // USE_ACM_REGISTRATION_PORT + + LOGTEXT2(_L8("\tCreated %d ACM Interfaces"), iNumberOfAcmFunctions); + } + +/** + * Called by UsbMan when it wants to stop the USB ACM class. + * + * @param aStatus The caller's request status: always set to KErrNone + */ +void CUsbACMClassController::Stop(TRequestStatus& aStatus) + { + LOG_FUNC; + + // We should always be started when this function is called (guaranteed by + // CUsbSession). + __ASSERT_DEBUG( iState == EUsbServiceStarted, _USB_PANIC(KAcmCcPanicCategory, EBadApiCallStop) ); + + TRequestStatus* reportStatus = &aStatus; + DoStop(); + User::RequestComplete(reportStatus, KErrNone); + } + +/** + * Gets information about the descriptor which this class provides. + * + * @param aDescriptorInfo Descriptor info structure filled in by this function + */ +void CUsbACMClassController::GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const + { + LOG_FUNC; + + aDescriptorInfo.iLength = KAcmDescriptorLength; + aDescriptorInfo.iNumInterfaces = KAcmNumberOfInterfacesPerAcmFunction*(iNumberOfAcmFunctions); + } + +/** +Destroys ACM functions we've already brought up. + */ +void CUsbACMClassController::DoStop() + { + LOG_FUNC; + + if (iState == EUsbServiceStarted) + { +#ifdef USE_ACM_REGISTRATION_PORT + TInt err = iComm.SetSignalsToSpace(iNumberOfAcmFunctions); + __ASSERT_DEBUG(err == KErrNone, User::Invariant()); + //the implementation in CRegistrationPort always return KErrNone + (void)err; + // If there is an error here, USBSVR will just ignore it, but + // it indicates that our interfaces are still up. We know the CSY + // doesn't raise an error, but an IPC error may have occurred. This is + // a problem with USBSVR in general- Stops are more or less assumed to + // work. +#else + // Destroy interfaces. Can't do anything with an error here. + static_cast(iAcmServer.DestroyFunctions(iNumberOfAcmFunctions)); +#endif // USE_ACM_REGISTRATION_PORT + + LOGTEXT2(_L8("\tDestroyed %d Interfaces"), iNumberOfAcmFunctions); + + iState = EUsbServiceIdle; + } + } + +/** + * Standard active object RunL. Never called because this class has no + * asynchronous requests. + */ +void CUsbACMClassController::RunL() + { + __ASSERT_DEBUG( EFalse, _USB_PANIC(KAcmCcPanicCategory, EUnusedFunction) ); + } + +/** + * Standard active object cancellation function. Never called because this + * class has no asynchronous requests. + */ +void CUsbACMClassController::DoCancel() + { + __ASSERT_DEBUG( EFalse, _USB_PANIC(KAcmCcPanicCategory, EUnusedFunction) ); + } + +/** + * Standard active object error function. Never called because this class has + * no asynchronous requests, and hence its RunL is never called. + * + * @param aError The error code (unused) + * @return Always KErrNone to avoid an active scheduler panic + */ +TInt CUsbACMClassController::RunError(TInt /*aError*/) + { + __ASSERT_DEBUG( EFalse, _USB_PANIC(KAcmCcPanicCategory, EUnusedFunction) ); + return KErrNone; + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/SRC/CUsbAcmClassImpCollection.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/SRC/CUsbAcmClassImpCollection.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,41 @@ +/* +* 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: +* Defines the implementation collection for the ACM class controller. +* +*/ + +/** + @file +*/ + +#include +#include +#include +#include +#include "CUsbACMClassController.h" + +// Define the private interface UIDs +const TImplementationProxy UsbCCImplementationTable[] = + { + IMPLEMENTATION_PROXY_ENTRY(0x101fbf22, CUsbACMClassController::NewL), + }; + +EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount) + { + aTableCount = sizeof(UsbCCImplementationTable) / sizeof(TImplementationProxy); + + return UsbCCImplementationTable; + } + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/group/AcmClassController.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/group/AcmClassController.mmp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,32 @@ +/* +* 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: +* ACMClassController.dll USB ACM Class Controller plug in, used to load/start/stop the ECACM CSY +* +*/ + +/** + @file +*/ + + +target acmclasscontroller.dll //Recommended unpaged + +start resource ../SRC/101fbf20.rss +target acmclasscontroller.rsc +END + +LIBRARY acmserver.lib + +#include "AcmClassControllerBase.mmp" diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/group/AcmClassControllerBase.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/group/AcmClassControllerBase.mmp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,43 @@ +/* +* 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: +* +*/ + + +CAPABILITY CommDD NetworkControl NetworkServices LocalServices ProtServ +targettype plugin + +UID 0x10009d8d 0x101fbf20 +VENDORID 0x70000001 + +SOURCEPATH ../SRC +SOURCE CUsbAcmClassImpCollection.cpp +SOURCE CUsbACMClassController.cpp + +SOURCEPATH ../../../../../inifile/src +SOURCE inifile.cpp + +USERINCLUDE ../INC +USERINCLUDE ../../../../../inifile/inc +USERINCLUDE ../../classimplementation/ecacm/public +USERINCLUDE ../../../../../usbman/server/public + +OS_LAYER_SYSTEMINCLUDE_SYMBIAN + +LIBRARY euser.lib +LIBRARY usbclasscontroller.lib +LIBRARY efsrv.lib + +#include diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/group/NumberOfAcmFunctions.ini --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/group/NumberOfAcmFunctions.ini Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,17 @@ +//[ACM X] is referring to the Xth ACM *function* +//which is accessed by the (X-1)th ACM *port*. + + +[ACM_CONF] +NumberOfAcmFunctions= 1 + +[ACM 1] +ProtocolNum= 1 //0x01 - code taken from USBCDC 1.1 Table 17- Hayes compatible modem +//ControlInterfaceName= CDCUserControlInterface +//DataInterfaceName= CDCUserDataInterface + +//[AMC 2] +//ProtocolNum= 255 //0xFF - Vendor-specific +//ControlInterfaceName= CDCSpecificControlInterface +//DataInterfaceName= CDCSpecificDataInterface + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/group/bld.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,36 @@ +/* +* Copyright (c) 2007-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: +* +*/ + +PRJ_EXPORTS +NumberOfAcmFunctions.ini /epoc32/data/z/private/101fe1db/numberofacmfunctions.ini + +PRJ_MMPFILES + +// +// Note the ACM Class controller must be built +// on all platforms +// + +// ACM Class Controller plugin support ACM::1 functions by default. The number of +// ACM functions can be changed by editing NumberOfAcmFunctions.ini file +AcmClassController.mmp + +PRJ_TESTMMPFILES + +// Old-style ACM Class Controller, using the registration port - used for regression testing +t_regport_AcmClassController.mmp + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/group/t_regport_AcmClassController.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classcontroller/group/t_regport_AcmClassController.mmp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,36 @@ +/* +* Copyright (c) 2005-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: +* t_regport_ACMClassController.dll Test USB ACM Class Controller +* plugin using registration port to control ACM interfaces. +* +*/ + +/** + @file +*/ + +// This macro means the ACM Class Controller uses the deprecated registration +// port mechanism to control ACM functions. +MACRO USE_ACM_REGISTRATION_PORT + +target t_regport_acmclasscontroller.dll + +start resource ../SRC/101fbf20.rss +target t_regport_acmclasscontroller.rsc +END + +LIBRARY c32.lib + +#include "AcmClassControllerBase.mmp" diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/EABI/acmserverU.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/EABI/acmserverU.def Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,12 @@ +EXPORTS + _ZN10RAcmServer15CreateFunctionsEj @ 1 NONAME + _ZN10RAcmServer15CreateFunctionsEjh @ 2 NONAME + _ZN10RAcmServer16DestroyFunctionsEj @ 3 NONAME + _ZN10RAcmServer5CloseEv @ 4 NONAME + _ZN10RAcmServer7ConnectEv @ 5 NONAME + _ZN10RAcmServerC1Ev @ 6 NONAME + _ZN10RAcmServerC2Ev @ 7 NONAME + _ZN10RAcmServerD1Ev @ 8 NONAME + _ZN10RAcmServerD2Ev @ 9 NONAME + _ZN10RAcmServer15CreateFunctionsEjhRK7TDesC16S2_ @ 10 NONAME + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/bwins/acmserverU.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/bwins/acmserverU.def Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,10 @@ +EXPORTS + ??0RAcmServer@@QAE@XZ @ 1 NONAME ; RAcmServer::RAcmServer(void) + ??1RAcmServer@@QAE@XZ @ 2 NONAME ; RAcmServer::~RAcmServer(void) + ?Connect@RAcmServer@@QAEHXZ @ 3 NONAME ; int RAcmServer::Connect(void) + ?CreateFunctions@RAcmServer@@QAEHI@Z @ 4 NONAME ; int RAcmServer::CreateFunctions(unsigned int) + ?CreateFunctions@RAcmServer@@QAEHIE@Z @ 5 NONAME ; int RAcmServer::CreateFunctions(unsigned int, unsigned char) + ?DestroyFunctions@RAcmServer@@QAEHI@Z @ 6 NONAME ; int RAcmServer::DestroyFunctions(unsigned int) + ?Close@RAcmServer@@QAEXXZ @ 7 NONAME ; void RAcmServer::Close(void) + ?CreateFunctions@RAcmServer@@QAEHIEABVTDesC16@@0@Z @ 8 NONAME ; int RAcmServer::CreateFunctions(unsigned int, unsigned char, class TDesC16 const &, class TDesC16 const &) + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/group/acmserver.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/group/acmserver.mmp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,47 @@ +/* +* Copyright (c) 2005-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: +* acmserver.dll Client side DLL for interaction with ACM function +* server. +* +*/ + +/** + @file +*/ + +TARGET acmserver.dll +CAPABILITY NetworkControl LocalServices NetworkServices CommDD ProtServ +TARGETTYPE DLL + +// dll uid + unique uid +UID 0x10005054 0x10281A7E + +VENDORID 0x70000001 + +SOURCEPATH ../src +SOURCE acmserver.cpp +SOURCE acmserverimpl.cpp +SOURCE acmserverclient.cpp + +USERINCLUDE ../inc +USERINCLUDE ../../ecacm/public +OS_LAYER_SYSTEMINCLUDE_SYMBIAN + +LIBRARY euser.lib +LIBRARY c32.lib + +#include + +UNPAGED diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/group/bld.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,26 @@ +/* +* Copyright (c) 2005-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: +* +*/ + +/** + @file +*/ + +PRJ_EXPORTS +../public/acmserver.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(usb/acmserver.h) + +PRJ_MMPFILES +acmserver.mmp diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/inc/acmserverclient.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/inc/acmserverclient.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,50 @@ +/* +* Copyright (c) 2005-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: +* +*/ + +/** + @file + @internalTechnology +*/ + +#ifndef __ACMSERVERCLIENT_H__ +#define __ACMSERVERCLIENT_H__ + +#include + +/** +Client-side interface to the ACM server to create new ACM functions. +This class MUST NOT be used outside Symbian. +*/ +NONSHARABLE_CLASS(RAcmServerClient) : public RSessionBase + { +public: + RAcmServerClient(); + ~RAcmServerClient(); + +public: + TInt Connect(); + TVersion Version() const; + +public: + TInt CreateFunctions(const TUint aNoAcms, const TUint8 aProtocolNum, const TDesC& aAcmControlIfcName, const TDesC& aAcmDataIfcName); + TInt DestroyFunctions(const TUint aNoAcms); + +private: + void ConnectL(); + }; + +#endif // __ACMSERVERCLIENT_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/inc/acmserverimpl.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/inc/acmserverimpl.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,57 @@ +/* +* Copyright (c) 2005-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: +* +*/ + +/** + @file + @internalTechnology +*/ + +#ifndef __ACMSERVERIMPL_H__ +#define __ACMSERVERIMPL_H__ + +#include +#include +#include "acmserverclient.h" + +/** +This is the 'body' of the RAcmServer - CAcmServerImpl handle-body system. +Handle-body enables us to alter the implementation of ACM control whilst +maintaining the same binary interface with clients. +This class MUST NOT be used outside Symbian. +Specifically, it is responsible for making sure that the ECACM CSY is loaded +(= ACM server running) and connecting an IPC channel to the ACM server. +*/ +NONSHARABLE_CLASS(CAcmServerImpl) : public CBase + { +public: + static CAcmServerImpl* NewL(); + ~CAcmServerImpl(); + +public: + TInt CreateFunctions(const TUint aNoAcms, const TUint8 aProtocolNum, const TDesC& aAcmControlIfcName, const TDesC& aAcmDataIfcName); + TInt DestroyFunctions(const TUint aNoAcms); + +private: + CAcmServerImpl(); + void ConstructL(); + +private: + RCommServ iCommServ; + RAcmServerClient iAcmServerClient; + }; + +#endif // __ACMSERVERIMPL_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/public/acmserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/public/acmserver.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,114 @@ +/* +* Copyright (c) 2005-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: +* +*/ + +/** + @file + @publishedPartner + @released +*/ + +#ifndef __ACMSERVER_H__ +#define __ACMSERVER_H__ + +#include + +class CAcmServerImpl; + +/** +Client interface to the ACM server to create new ACM functions. +This class is intended to be used both inside and outside Symbian to bring up +and tear down ACM functions. +*/ +NONSHARABLE_CLASS(RAcmServer) + { +public: + /** + Standard constructor. Does not connect the handle to the service provider. + */ + IMPORT_C RAcmServer(); + + /** + Standard destructor. Does not disconnect the handle from the service + provider. + */ + IMPORT_C ~RAcmServer(); + +public: + /** + Connects this handle to the service provider. + @return Error. + */ + IMPORT_C TInt Connect(); + + /** + Closes this handle to the service provider. If the handle has been + successfully Connected, it must eventually be Closed. + */ + IMPORT_C void Close(); + +public: + /** + Creates aNoAcms ACM functions using the default settings. + The default setting includes KDefaultAcmProtocolNum- protocol code 0x01 + (Hayes compatible, from USBCDC 1.1 Table 17). + @param aNoAcms Number of ACM functions to be created. + @return Error. + */ + IMPORT_C TInt CreateFunctions(const TUint aNoAcms); + + /** + Creates aNoAcms ACM functions using the protocol number given (as defined + in USBCDC 1.1 - Table 17). + @param aNoAcms Number of ACM functions to be created. + @param aProtocolNum Protocol setting for the ACM functions to be created. + @return Error. + */ + IMPORT_C TInt CreateFunctions(const TUint aNoAcms, const TUint8 aProtocolNum); + + /** + Creates aNoAcms ACM functions using the protocol number given (as defined + in USBCDC 1.1 - Table 17). + @param aNoAcms Number of ACM functions to be created. + @param aProtocolNum Protocol setting for the ACM function to be created. + @param aAcmControlIfcName Control Interface Name for the ACM function to be created. + @param aAcmDataIfcName Data Interface Name for the ACM function to be created. + @return Error. + */ + IMPORT_C TInt CreateFunctions(const TUint aNoAcms, const TUint8 aProtocolNum, const TDesC& aAcmControlIfcName, const TDesC& aAcmDataIfcName); + + /** + Destroys aNoAcms ACM functions. + Class Controllers MUST NOT destroy more ACM functions than they have + successfully created. + @param aNoAcms Number of ACM interfaces to destroy. + @return Error. + */ + IMPORT_C TInt DestroyFunctions(const TUint aNoAcms); + +private: + /** + Private copy constructor to avoid problems with multiple ownership of + RAcmServerImpls. + */ + RAcmServer(const RAcmServer& aObjectToCopy); + +private: // owned + // The 'body' used by this handle. + CAcmServerImpl* iImpl; + }; + +#endif // __ACMSERVER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/src/acmserver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/src/acmserver.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,125 @@ +/* +* Copyright (c) 2005-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: +* +*/ + +/** + @file +*/ + +#include +#include +#include "acmserverimpl.h" +#include +#include "acmserverconsts.h" + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ACMSVRCLI"); +#endif + +/** Panic category for users of RAcmServer. */ +#ifdef _DEBUG +_LIT(KAcmSrvPanicCat, "ACMSVR"); +#endif + +/** Panic codes for users of RAcmServer. */ +enum TAcmServerClientPanic + { + /** The handle has not been connected. */ + EPanicNotConnected = 0, + + /** The handle has already been connected. */ + EPanicAlreadyConnected = 1, + + /** The client has requested to instantiate zero ACM functions, which + makes no sense. */ + EPanicCantInstantiateZeroAcms = 2, + + /** The client has requested to destroy zero ACM functions, which makes no + sense. */ + EPanicCantDestroyZeroAcms = 3, + + /** Close has not been called before destroying the object. */ + EPanicNotClosed = 4, + }; + +EXPORT_C RAcmServer::RAcmServer() + : iImpl(NULL) + { + LOG_FUNC + } + +EXPORT_C RAcmServer::~RAcmServer() + { + LOG_FUNC + + __ASSERT_DEBUG(!iImpl, _USB_PANIC(KAcmSrvPanicCat, EPanicNotClosed)); + } + +EXPORT_C TInt RAcmServer::Connect() + { + LOG_FUNC + + __ASSERT_DEBUG(!iImpl, _USB_PANIC(KAcmSrvPanicCat, EPanicAlreadyConnected)); + TRAPD(err, iImpl = CAcmServerImpl::NewL()); + return err; + } + +EXPORT_C void RAcmServer::Close() + { + LOG_FUNC + + delete iImpl; + iImpl = NULL; + } + +EXPORT_C TInt RAcmServer::CreateFunctions(const TUint aNoAcms) + { + LOG_FUNC + LOGTEXT2(_L8("\taNoAcms = %d"), aNoAcms); + + __ASSERT_DEBUG(iImpl, _USB_PANIC(KAcmSrvPanicCat, EPanicNotConnected)); + __ASSERT_DEBUG(aNoAcms, _USB_PANIC(KAcmSrvPanicCat, EPanicCantInstantiateZeroAcms)); + return iImpl->CreateFunctions(aNoAcms, KDefaultAcmProtocolNum, KControlIfcName, KDataIfcName); + } + +EXPORT_C TInt RAcmServer::CreateFunctions(const TUint aNoAcms, const TUint8 aProtocolNum) + { + LOG_FUNC + LOGTEXT3(_L8("\taNoAcms = %d, aProtocolNum = %d"), aNoAcms, aProtocolNum); + + __ASSERT_DEBUG(iImpl, _USB_PANIC(KAcmSrvPanicCat, EPanicNotConnected)); + __ASSERT_DEBUG(aNoAcms, _USB_PANIC(KAcmSrvPanicCat, EPanicCantInstantiateZeroAcms)); + return iImpl->CreateFunctions(aNoAcms, aProtocolNum, KControlIfcName, KDataIfcName); + } + +EXPORT_C TInt RAcmServer::CreateFunctions(const TUint aNoAcms, const TUint8 aProtocolNum, const TDesC& aAcmControlIfcName, const TDesC& aAcmDataIfcName) + { + LOG_FUNC + + __ASSERT_DEBUG(iImpl, _USB_PANIC(KAcmSrvPanicCat, EPanicNotConnected)); + __ASSERT_DEBUG(aNoAcms, _USB_PANIC(KAcmSrvPanicCat, EPanicCantInstantiateZeroAcms)); + return iImpl->CreateFunctions(aNoAcms, aProtocolNum, aAcmControlIfcName, aAcmDataIfcName); + } + +EXPORT_C TInt RAcmServer::DestroyFunctions(const TUint aNoAcms) + { + LOG_FUNC + LOGTEXT2(_L8("\taNoAcms = %d"), aNoAcms); + + __ASSERT_DEBUG(iImpl, _USB_PANIC(KAcmSrvPanicCat, EPanicNotConnected)); + __ASSERT_DEBUG(aNoAcms, _USB_PANIC(KAcmSrvPanicCat, EPanicCantDestroyZeroAcms)); + return iImpl->DestroyFunctions(aNoAcms); + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/src/acmserverclient.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/src/acmserverclient.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,90 @@ +/* +* Copyright (c) 2005-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: +* +*/ + +/** + @file +*/ + +#include +#include "acmserverclient.h" +#include "acmserverconsts.h" +#include +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ACMSVRCLI"); +#endif + +/** Constructor */ +RAcmServerClient::RAcmServerClient() + { + LOG_FUNC + } + +/** Destructor */ +RAcmServerClient::~RAcmServerClient() + { + LOG_FUNC + } + +/** +Getter for the version of the server. +@return Version of the server +*/ +TVersion RAcmServerClient::Version() const + { + LOG_FUNC + + return TVersion( KAcmSrvMajorVersionNumber, + KAcmSrvMinorVersionNumber, + KAcmSrvBuildNumber + ); + } + +/** +Connect the handle to the server. +Must be called before all other methods (except Version and Close). +@return Symbian error code +*/ +TInt RAcmServerClient::Connect() + { + LOG_FUNC + + return CreateSession(KAcmServerName, Version(), 1); + } + +TInt RAcmServerClient::CreateFunctions(const TUint aNoAcms, const TUint8 aProtocolNum, const TDesC& aAcmControlIfcName, const TDesC& aAcmDataIfcName) + { + LOG_FUNC + LOGTEXT5(_L("\taNoAcms = %d, aProtocolNum = %d, Control Ifc Name = %S, Data Ifc Name = %S"), + aNoAcms, aProtocolNum, &aAcmControlIfcName, &aAcmDataIfcName); + + TIpcArgs args; + args.Set(0, aNoAcms); + args.Set(1, aProtocolNum); + args.Set(2, &aAcmControlIfcName); + args.Set(3, &aAcmDataIfcName); + return SendReceive(EAcmCreateAcmFunctions, args); + } + +TInt RAcmServerClient::DestroyFunctions(const TUint aNoAcms) + { + LOG_FUNC + LOGTEXT2(_L8("\taNoAcms = %d"), aNoAcms); + + return SendReceive(EAcmDestroyAcmFunctions, TIpcArgs(aNoAcms)); + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/src/acmserverimpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/acmserver/src/acmserverimpl.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,89 @@ +/* +* Copyright (c) 2005-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: +* +*/ + +/** + @file +*/ + +#include +#include "acmserverimpl.h" +#include +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ACMSVRCLI"); +#endif + +/** Constructor */ +CAcmServerImpl::CAcmServerImpl() + { + LOG_FUNC + } + +/** Destructor */ +CAcmServerImpl::~CAcmServerImpl() + { + LOG_FUNC + + iCommServ.Close(); + iAcmServerClient.Close(); + } + +/** +2-phase construction. +@return Ownership of a new CAcmServerImpl. +*/ +CAcmServerImpl* CAcmServerImpl::NewL() + { + LOG_STATIC_FUNC_ENTRY + + CAcmServerImpl* self = new(ELeave) CAcmServerImpl; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void CAcmServerImpl::ConstructL() + { + LOG_FUNC + + // In order to connect a session, the ECACM CSY must be loaded (it + // contains the server). + LEAVEIFERRORL(iCommServ.Connect()); + LEAVEIFERRORL(iCommServ.LoadCommModule(KAcmCsyName)); + // NB RCommServ::Close undoes LoadCommModule. + LEAVEIFERRORL(iAcmServerClient.Connect()); + // iCommServ is eventually cleaned up in our destructor. It must be held + // open at least as long as our session on the ACM server, otherwise + // there's a risk the ACM server will be pulled from under our feet. + } + +TInt CAcmServerImpl::CreateFunctions(const TUint aNoAcms, const TUint8 aProtocolNum, const TDesC& aAcmControlIfcName, const TDesC& aAcmDataIfcName) + { + LOG_FUNC + + return iAcmServerClient.CreateFunctions(aNoAcms, aProtocolNum, aAcmControlIfcName, aAcmDataIfcName); + } + +TInt CAcmServerImpl::DestroyFunctions(const TUint aNoAcms) + { + LOG_FUNC + LOGTEXT2(_L8("\taNoAcms = %d"), aNoAcms); + + return iAcmServerClient.DestroyFunctions(aNoAcms); + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/bld.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,19 @@ +/* +* Copyright (c) 2007-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 "acmserver/group/bld.inf" +#include "ecacm/group/bld.inf" diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/BWINS/ECACMu.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/BWINS/ECACMu.def Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,3 @@ +EXPORTS + LibEntryL @ 1 NONAME + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/EABI/ecacmU.DEF --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/EABI/ecacmU.DEF Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,3 @@ +EXPORTS + LibEntryL @ 1 NONAME + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/group/BLD.INF --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/group/BLD.INF Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,33 @@ +/* +* Copyright (c) 1999-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: +* Build information for USB class support +* +*/ + +/** + @file +*/ + + +PRJ_EXPORTS +../public/AcmInterface.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(acminterface.h) +ecacm.ini /epoc32/data/z/system/data/ecacm.ini +../public/AcmConfig.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(usb/acmconfig.h) + +PRJ_MMPFILES +ECACM.MMP + +PRJ_TESTEXPORTS +../public/acmserverconsts.h SYMBIAN_OS_LAYER_PLATFORM_EXPORT_PATH(usb/acmserverconsts.h) diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/group/ECACM.MMP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/group/ECACM.MMP Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,77 @@ +/* +* 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: +* Top-level project file for ECACM.CSY +* ecacm.csy Comms server plug-in for USB +* +*/ + +/** + @file +*/ + + +TARGET ecacm.csy +CAPABILITY CommDD PowerMgmt ReadDeviceData WriteDeviceData TrustedUI ProtServ NetworkControl NetworkServices LocalServices ReadUserData WriteUserData +TARGETTYPE dll + +NOEXPORTLIBRARY + +// +// We have a laggard, ill-defined UID3 which must be kept +// for old platforms for BC. For newer platforms, we use +// KUidECACM = 0x10201EF6 +// +uid 0x10005054 0x10201EF6 + +SOURCEPATH ../src +SOURCE AcmPort.cpp +SOURCE AcmPortFactory.cpp +SOURCE AcmReader.cpp +SOURCE AcmWriter.cpp +SOURCE linkstatenotifier.cpp +SOURCE ActiveReader.cpp +SOURCE ActiveReadOneOrMoreReader.cpp +SOURCE ActiveWriter.cpp +SOURCE BreakController.cpp +SOURCE CdcAcmClass.cpp +SOURCE CdcInterfaceBase.cpp +SOURCE CdcControlInterface.cpp +SOURCE CdcControlInterfaceReader.cpp +SOURCE CdcDataInterface.cpp +SOURCE ClassDescriptor.cpp +SOURCE DllMain.cpp +SOURCE RegistrationPort.cpp +SOURCE RequestHeader.cpp +SOURCE acmserver.cpp +SOURCE acmsession.cpp +SOURCE ActiveDataAvailableNotifier.cpp + +SOURCEPATH ../../../../../../inifile/src +SOURCE inifile.cpp + +USERINCLUDE ../inc +USERINCLUDE ../public +USERINCLUDE ../../../../../../inifile/inc +OS_LAYER_SYSTEMINCLUDE_SYMBIAN + +LIBRARY euser.lib +LIBRARY c32.lib +LIBRARY efsrv.lib + +#include + +VENDORID 0x70000001 + +UNPAGED diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/group/ecacm.ini --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/group/ecacm.ini Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,21 @@ +; Copyright (c) 2004-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: +; Ini file for ECACM plug-in ( EPOC Comms Abstract Control Model Comms System Module ). +; +; + + +[HostUSBDeviceDriver] +CanHandleZLP= 0; + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmConstants.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmConstants.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,25 @@ +/* +* 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: +* +*/ + +#ifndef __ACMCONSTANTS_H__ +#define __ACMCONSTANTS_H__ + +#include + +const TUint KEcacmAOPriority = 10; + +#endif // __ACMCONSTANTS_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmPanic.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmPanic.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,38 @@ +/* +* 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: +* +*/ + +#ifndef __ACMPANIC_H__ +#define __ACMPANIC_H__ + +/** + * Panic codes. These all represent programming errors. + */ +enum TAcmPanic + { + ///< Mainly NULL pointers. + EPanicInternalError = 0, + + ///< Illegal state in a state machine. + EPanicIllegalState = 1, + + ///< Unknown device state event + EPanicUnknownDeviceState= 2, + }; + +_LIT(KAcmPanicCat, "ECACM"); + +#endif // __ACMPANIC_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmPort.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmPort.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,159 @@ +/* +* 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: +* +*/ + +#ifndef __ACMPORT_H__ +#define __ACMPORT_H__ + +#include +#include "CdcAcmClass.h" +#include "HostPushedChangeObserver.h" +#include "BreakObserver.h" + +class CAcmPortFactory; +class CAcmReader; +class CAcmWriter; +class MAcmPortObserver; + +NONSHARABLE_CLASS(CAcmPort) : public CPort, + public MHostPushedChangeObserver, + public MBreakObserver +/** + * Concrete ACM port type, derived from C32's CPort. + */ + { +public: + static CAcmPort* NewL(const TUint aUnit, MAcmPortObserver& aFactory); + ~CAcmPort(); + +public: + void SetAcm(CCdcAcmClass* aAcm); + inline CCdcAcmClass* Acm(); + +private: + CAcmPort(const TUint aUnit, MAcmPortObserver& aFactory); + void ConstructL(); + +private: // from CPort + virtual void StartRead(const TAny* aClientBuffer,TInt aLength); + virtual void ReadCancel(); + virtual TInt QueryReceiveBuffer(TInt& aLength) const; + virtual void ResetBuffers(TUint aFlags); + virtual void StartWrite(const TAny* aClientBuffer,TInt aLength); + virtual void WriteCancel(); + virtual void Break(TInt aTime); + virtual void BreakCancel(); + virtual TInt GetConfig(TDes8& aDes) const; + virtual TInt SetConfig(const TDesC8& aDes); + virtual TInt SetServerConfig(const TDesC8& aDes); + virtual TInt GetServerConfig(TDes8& aDes); + virtual TInt GetCaps(TDes8& aDes); + virtual TInt GetSignals(TUint& aSignals); + virtual TInt SetSignalsToMark(TUint aSignals); + virtual TInt SetSignalsToSpace(TUint aSignals); + virtual TInt GetReceiveBufferLength(TInt& aLength) const; + virtual TInt SetReceiveBufferLength(TInt aSignals); + virtual void Destruct(); + virtual void FreeMemory(); + virtual void NotifySignalChange(TUint aSignalMask); + virtual void NotifySignalChangeCancel(); + virtual void NotifyConfigChange(); + virtual void NotifyConfigChangeCancel(); + virtual void NotifyFlowControlChange(); + virtual void NotifyFlowControlChangeCancel(); + virtual void NotifyBreak(); + virtual void NotifyBreakCancel(); + virtual void NotifyDataAvailable(); + virtual void NotifyDataAvailableCancel(); + virtual void NotifyOutputEmpty(); + virtual void NotifyOutputEmptyCancel(); + virtual TInt GetFlowControlStatus(TFlowControl& aFlowControl); + virtual TInt GetRole(TCommRole& aRole); + virtual TInt SetRole(TCommRole aRole); + +private: // from MBreakObserver + void BreakRequestCompleted(); + void BreakStateChange(); + +private: // from MHostPushedChangeObserver + virtual void HostConfigChange(const TCommConfigV01& aConfig); + virtual void HostSignalChange(TBool aDtr, TBool aRts); + +private: // utility + TInt SetSignals(TUint32 aNewSignals); + void HandleConfigNotification(TBps aBps, + TDataBits aDataBits, + TParity aParity, + TStopBits aStopBits, + TUint aHandshake); + // iSignals stores the lines in DCE mode- these functions convert between + // this and whatever the client expects, according to our current mode. + TUint32 ConvertSignals(TUint32 aSignals) const; + TUint32 ConvertAndFilterSignals(TUint32 aSignals) const; + TInt DoSetBufferLengths(TUint aLength); + +public: // owned data + TCommConfigV01 iCommConfig; + TCommNotificationPckg iCommNotificationDes; + TCommNotificationV01& iCommNotification; + +private: // unowned + CCdcAcmClass* iAcm; + MAcmPortObserver& iObserver; + +private: // owned + CAcmReader* iReader; + CAcmWriter* iWriter; + + // Current server configuration settings + TCommServerConfigV01 iCommServerConfig; + // Flag indicating whether there is a current signal line change + // notification request outstanding + TBool iNotifySignalChange; + // Flag indicating whether there is a current configuration change + // notification request outstanding + TBool iNotifyConfigChange; + // Flag indicating whether there is a current break notification + // request outstanding + TBool iNotifyBreak; + // The current emulated signal lines + TUint32 iSignals; + // The signal mask associated with the current signal change notification + // request + TUint iNotifySignalMask; + // Role of the serial port (DTE or DCE) + TCommRole iRole; + TBool iCancellingBreak; + // Flag indicating whether we're currently requesting a break. + TBool iBreak; + + // The port number. + const TUint iUnit; + }; + +// Inlines + +CCdcAcmClass* CAcmPort::Acm() +/** + * Accessor function for the ACM class. + * + * @return Pointer to the port's ACM class instance. + */ + { + return iAcm; + } + +#endif // __ACMPORT_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmPortFactory.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmPortFactory.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,76 @@ +/* +* 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: +* +*/ + +#ifndef __ACMPORTFACTORY_H__ +#define __ACMPORTFACTORY_H__ + +#include +#include "AcmPortObserver.h" +#include "RegistrationPort.h" +#include "acmcontroller.h" +#include +#include + +class CCdcAcmClass; +class CAcmPort; +class CAcmServer; + +NONSHARABLE_CLASS(CAcmPortFactory) : public CSerial, + public MAcmController, + public MAcmPortObserver +/** + * Definition of concrete CSerial-derived type. + */ + { +public: + static CAcmPortFactory* NewL(); + ~CAcmPortFactory(); + +private: + CAcmPortFactory(); + void ConstructL(); + +private: // from CSerial + TSecurityPolicy PortPlatSecCapability(TUint aPort) const; + virtual CPort* NewPortL(const TUint aUnit); + virtual void Info(TSerialInfo &aSerialInfo); + +private: // from MAcmController + TInt CreateFunctions(const TUint aNoAcms, const TUint8 aProtocolNum, const TDesC16& aAcmControlIfcName, const TDesC16& aAcmDataIfcName); + void DestroyFunctions(const TUint aNoAcms); + +private: // from MAcmPortObserver + void AcmPortClosed(const TUint aUnit); + +private: // utility + void CreateFunctionL(const TUint8 aProtocolNum, const TDesC16& aAcmControlIfcName, const TDesC16& aAcmDataIfcName); + void CheckAcmArray(); + void LogPortsAndFunctions(); + void PublishAcmConfig(); + +private: // unowned + RPointerArray iAcmPortArray; + +private: // owned + RPointerArray iAcmClassArray; + CAcmServer* iAcmServer; + RProperty iAcmProperty; + TPckgBuf iConfigBuf; + TBool iOwned; + }; + +#endif // __ACMPORTFACTORY_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmPortObserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmPortObserver.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,30 @@ +/* +* 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: +* +*/ + +#ifndef __ACMPORTOBSERVER_H__ +#define __ACMPORTOBSERVER_H__ + +class MAcmPortObserver +/** + * Interface for notification of the ACM port being closed. + */ + { +public: + virtual void AcmPortClosed(const TUint aUnit) = 0; + }; + +#endif // __ACMPORTOBSERVER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmReader.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmReader.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,203 @@ +/* +* 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: +* +*/ + +#ifndef __ACMREADER_H__ +#define __ACMREADER_H__ + +#include +#include +#include "ReadObserver.h" +#include "ReadOneOrMoreObserver.h" +#include "NotifyDataAvailableObserver.h" + +class CCdcAcmClass; +class CAcmPort; + +NONSHARABLE_CLASS(CAcmReader) : public CBase, + public MReadObserver, + public MReadOneOrMoreObserver, + public MNotifyDataAvailableObserver +/** + * CAcmReader maintains the port's read buffer, fields requests from the port + * (its client) for data, and administers getting more data from the LDD. + * + * It presents an interface for requesting data- whether the required data is + * immediately available in the buffer or not, it eventually completes the + * client (port)'s request using CPort::IPCWrite and CPort::ReadCompleted. + * + * It uses the CCdcAcmClass to ask for more data from the host. Consequently + * it implements MReadObserver and MReadOneOrMoreObserver to be notified when + * data has come in. + */ + { +public: + static CAcmReader* NewL(CAcmPort& aPort, + TUint aBufSize); + ~CAcmReader(); + +public: // APIs for reading + void Read(const TAny* aClientBuffer, TUint aMaxLen); + void ReadOneOrMore(const TAny* aClientBuffer, TUint aMaxLen); + void ReadCancel(); + void NotifyDataAvailable(); + void NotifyDataAvailableCancel(); + inline TBool IsNotifyDataAvailableQueryPending() const; + +public: // buffer APIs + TUint BufLen() const; + inline TUint BufSize() const; + void ResetBuffer(); + TInt SetBufSize(TUint aSize); + void SetTerminators(const TCommConfigV01& aConfig); + +private: + CAcmReader(CAcmPort& aPort, + TUint aBufSize); + void ConstructL(); + +private: // from MReadObserver + void ReadCompleted(TInt aError); + +private: // from MReadOneOrMoreObserver + void ReadOneOrMoreCompleted(TInt aError); + +private: // from MNotifyDataAvailableObserver + void NotifyDataAvailableCompleted(TInt aError); + +private: // utilities + inline TBool BufWrap() const; + void CheckBufferEmptyAndResetPtrs(); + void CheckNewRequest(const TAny* aClientBuffer, TUint aMaxLen); + void CheckForBufferedTerminatorsAndProceed(); + + void WriteBackData(TUint aLength); + void CompleteRequest(TInt aError); + + void ReadWithoutTerminators(); + void ReadWithTerminators(); + + void IssueRead(); + void IssueReadOneOrMore(); + + TInt FindTerminator() const; + TInt PartialFindTerminator(TUint8* aFrom, TUint8* aTo, TInt& aPos) const; + +private: // owned- information on the current request from the port (if any) + + enum TRequestType + { + ERead, + EReadOneOrMore, + ENotifyDataAvailable + }; + + NONSHARABLE_STRUCT(TRequestData) + { + // Pointer to the client's memory to put the data into. This is also + // used as a flag for whether we have an outstanding request or not. + const TAny* iClientPtr; + // type of the current request + TRequestType iRequestType; + }; + // This struct is populated when a new client request comes in. + TRequestData iCurrentRequest; + +private: // owned- information on our attempt to satisfy the current request + // from the port (if any) + + // Starts as the amount of data requested by the client. + // This may not be the same as the + // amount of data given back to the client when the request is + // completed, for instance if the read is a one-or-more, or if + // terminators are defined. + // Will be the number of bytes remaining to be read before we can + // complete the client's request. + TUint iLengthToGo; + + // Offset into iClientPtr to write more data to using IPCWrite. + TUint iOffsetIntoClientsMemory; + +private: // owned- information on the buffer + + // The current actual size of the buffer. + TUint iBufSize; + + // Our buffer of data. + HBufC8* iBuffer; + + // These TUints are pointers to various places in iBuffer. + + // Pointer to where data will be placed into our buffer (from the LDD). + TUint8* iInPtr; + // Pointer to where data will leave our buffer (to go up to the client). + TUint8* iOutPtr; + // Pointer to the start of the buffer. + TUint8* iBufStart; + + // Descriptor pointer into iBuffer. We use this in Read and ReadOneOrMore + // calls to the LDD to get data written into iBuffer. + TPtr8 iInBuf; + +private: // owned- information on the terminator characters + TUint iTerminatorCount; + TFixedArray iTerminator; + +private: // unowned + // Used to access the (RComm) client's memory and to complete their + // request. Also accesses the ACM class through the port. (The ACM class + // may come and go, following the lifetime of the registration port, not + // the ACM port.) + CAcmPort& iPort; + }; + +TBool CAcmReader::BufWrap() const +/** + * This function indicates whether the circular buffer has wrapped. + * + * @return TBool Indication of whether the buffer has wrapped. + */ + { + TBool ret = EFalse; + if ( iOutPtr > iInPtr ) + { + ret = ETrue; + } + + return ret; + } + +TUint CAcmReader::BufSize() const +/** + * Accessor for current buffer size. + * + * @return The current buffer size. + */ + { + return iBufSize; + } + +TBool CAcmReader::IsNotifyDataAvailableQueryPending() const +/** + * check if a NotifyDataAvailable query is in progress + * + * @return ETrue if a NotifyDataAvailable query is pending, EFalse if not. + */ + { + return ((iCurrentRequest.iClientPtr)&&(ENotifyDataAvailable==iCurrentRequest.iRequestType)); + } + +#endif // __ACMREADER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmUtils.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmUtils.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,31 @@ +/* +* 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: +* +*/ + +#ifndef __ACMUTILS_H__ +#define __ACMUTILS_H__ + +#include + +// Macros to save a bit of ROM space in release builds- the checking form of +// Pop only really needs to be run once anyway. +#ifdef _DEBUG +#define CLEANUPSTACK_POP(aaa) CleanupStack::Pop(aaa) +#else +#define CLEANUPSTACK_POP(aaa) CleanupStack::Pop() +#endif + +#endif // __ACMUTILS_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmWriter.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/AcmWriter.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,104 @@ +/* +* 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: +* +*/ + +#ifndef __ACMWRITER_H__ +#define __ACMWRITER_H__ + +#include +#include "WriteObserver.h" + +class CAcmPort; + +NONSHARABLE_CLASS(CAcmWriter) : public CBase, + public MWriteObserver +/** + * CAcmWriter presents an interface for writing data to the bulk endpoint on + * the LDD. + * Note that we reject write requests bigger than the buffer. We also don't + * support KConfigWriteBufferedComplete, so client requests are turned into + * one write request on the LDD. When the LDD request completes, we complete + * to the client. + */ + { +public: + static CAcmWriter* NewL(CAcmPort& aPort, TUint aBufSize); + ~CAcmWriter(); + +public: // APIs for writing + void Write(const TAny* aClientBuffer, TUint aLength); + void WriteCancel(); + +public: // buffer APIs + void ResetBuffer(); + TInt SetBufSize(TUint aSize); + +private: + CAcmWriter(CAcmPort& aPort, TUint aBufSize); + void ConstructL(); + +private: // from MWriteObserver + void WriteCompleted(TInt aError); + +private: // utility + void ReadDataFromClient(); + void CheckNewRequest(const TAny* aClientBuffer, TUint aLength); + void CompleteRequest(TInt aError); + void IssueWrite(); + +private: // owned- information on the current request from the port (if any) + + NONSHARABLE_STRUCT(TRequestData) + { + // Pointer to the client's memory to get the data to write. + const TAny* iClientPtr; + + // Number of bytes to write. + TUint iLength; + }; + // This struct is populated when a new client request comes in. + TRequestData iCurrentRequest; + +private: // owned- information on our attempt to satisfy the current request + // from the port (if any) + + // Offset into iClientPtr to get more data from using IPCRead. + TUint iOffsetIntoClientsMemory; + + // Number of bytes remaining to be written before we can complete the + // client's request. + TUint iLengthToGo; + +private: // owned- information on the buffer + + // The current actual size of the buffer. + TUint iBufSize; + + // Our buffer of data. This is for temporarily storing RComm client data + // while we are writing it to the LDD. + HBufC8* iBuffer; + + // Descriptor pointer into iBuffer. We use this in Write calls to the LDD. + TPtr8 iBuf; + +private: // unowned + // Used to access the (RComm) client's memory and to complete their + // request. Also accesses the ACM class through the port. (The ACM class + // may come and go, but not the ACM port.) + CAcmPort& iPort; + }; + +#endif // __ACMWRITER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ActiveDataAvailableNotifier.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ActiveDataAvailableNotifier.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,60 @@ +/* +* Copyright (c) 2007-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: +* +*/ + +#ifndef __ACTIVEDATAAVAILABLENOTIFIER_H__ +#define __ACTIVEDATAAVAILABLENOTIFIER_H__ + +#include +#include + +class RDevUsbcClient; +class MNotifyDataAvailableObserver; + +NONSHARABLE_CLASS(CActiveDataAvailableNotifier) : public CActive +/** + * Active object used to notify the parent when there is data available + * to be read from the LDD. Since the LDD does not support this functionality + * directly RDevUsbcClient::ReadOneOrMore() is used instead, specifying a + * zero byte read into a descriptor which is owned by the class. + */ + { +public: + static CActiveDataAvailableNotifier* NewL(MNotifyDataAvailableObserver& aParent, + RDevUsbcClient& aLdd, TEndpointNumber aEndpoint); + ~CActiveDataAvailableNotifier(); + +public: + void NotifyDataAvailable(); + +private: + CActiveDataAvailableNotifier(MNotifyDataAvailableObserver& aParent, + RDevUsbcClient& aLdd, TEndpointNumber aEndpoint); + +private: // from CActive + virtual void DoCancel(); + virtual void RunL(); + +private: // unowned + MNotifyDataAvailableObserver& iParent; + RDevUsbcClient& iLdd; + +private: // owned + TEndpointNumber iEndpoint; + TBuf8<1> iUnusedBuf; // passed to the LDD in order to carry out the zero byte read (length must be > 0) + }; + +#endif // __ACTIVEDATAAVAILABLENOTIFIER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ActiveReadOneOrMoreReader.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ActiveReadOneOrMoreReader.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,56 @@ +/* +* 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: +* +*/ + +#ifndef __ACTIVEREADONEORMOREREADER_H__ +#define __ACTIVEREADONEORMOREREADER_H__ + +#include +#include + +class RDevUsbcClient; +class MReadOneOrMoreObserver; + +NONSHARABLE_CLASS(CActiveReadOneOrMoreReader) : public CActive +/** + * Active object to post ReadOneOrMore requests on the LDD. + */ + { +public: + static CActiveReadOneOrMoreReader* NewL(MReadOneOrMoreObserver& aParent, + RDevUsbcClient& aLdd, TEndpointNumber aEndpoint); + ~CActiveReadOneOrMoreReader(); + +public: + void ReadOneOrMore(TDes8& aDes, TInt aLength); + +private: + CActiveReadOneOrMoreReader(MReadOneOrMoreObserver& aParent, + RDevUsbcClient& aLdd, TEndpointNumber aEndpoint); + +private: // from CActive + virtual void DoCancel(); + virtual void RunL(); + +private: // unowned + MReadOneOrMoreObserver& iParent; + RDevUsbcClient& iLdd; + +private: // owned + TEndpointNumber iEndpoint; + }; + +#endif // __ACTIVEREADONEORMOREREADER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ActiveReader.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ActiveReader.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,54 @@ +/* +* 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: +* +*/ + +#ifndef __ACTIVEREADER_H__ +#define __ACTIVEREADER_H__ + +#include +#include + +class RDevUsbcClient; +class MReadObserver; + +NONSHARABLE_CLASS(CActiveReader) : public CActive +/** + * Active object to post read requests on the LDD. + */ + { +public: + static CActiveReader* NewL(MReadObserver& aParent, RDevUsbcClient& aLdd, TEndpointNumber aEndpoint); + ~CActiveReader(); + +public: + void Read(TDes8& aDes, TInt aLen); + +private: + CActiveReader(MReadObserver& aParent, RDevUsbcClient& aLdd, TEndpointNumber aEndpoint); + +private: // from CActive + virtual void DoCancel(); + virtual void RunL(); + +private: // unowned + MReadObserver& iParent; + RDevUsbcClient& iLdd; + +private: // owned + TEndpointNumber iEndpoint; + }; + +#endif // __ACTIVEREADER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ActiveWriter.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ActiveWriter.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,72 @@ +/* +* 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: +* +*/ + +#ifndef __ACTIVEWRITER_H__ +#define __ACTIVEWRITER_H__ + +#include +#include + +class RDevUsbcClient; +class MWriteObserver; + +NONSHARABLE_CLASS(CActiveWriter) : public CActive +/** + * Active object to post write requests on the LDD. + */ + { +public: + static CActiveWriter* NewL(MWriteObserver& aParent, RDevUsbcClient& aLdd, TEndpointNumber aEndpoint); + ~CActiveWriter(); + +public: + void Write(const TDesC8& aDes, + TInt aLen, + TBool aZlp); + +private: + CActiveWriter(MWriteObserver& aParent, RDevUsbcClient& aLdd, TEndpointNumber aEndpoint); + +private: // from CActive + virtual void DoCancel(); + virtual void RunL(); + +private: // unowned + MWriteObserver& iParent; + RDevUsbcClient& iLdd; + +private: // owned + TEndpointNumber iEndpoint; + + enum TWritingState + { + EFirstMessagePart, + EFinalMessagePart, + ECompleteMessage, + }; + + enum + { + KMaxPacketSize = 64, + }; + + TWritingState iWritingState; + TPtrC8 iFirstPortion; + TPtrC8 iSecondPortion; + }; + +#endif // __ACTIVEWRITER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/BreakController.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/BreakController.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,101 @@ +/* +* 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: +* +*/ + +#ifndef __BREAKCONTROLLER_H__ +#define __BREAKCONTROLLER_H__ + +#include + +class CCdcAcmClass; +class MHostPushedChangeObserver; + +NONSHARABLE_CLASS(CBreakController) : public CActive +/** + * Break (timed signal) handler + * + * This class provides a simple active object that manages the timing aspect + * of a break: there is only one of these, that is used to manage both + * client-induced breaks (routed in via the ACM port) and break commands sent + * here from the (USB) Host. + * + * Note that only one of the device and the host can be 'in charge of' a + * break. If the host, say, is dealing with a timed break, then it is illegal + * for the device to issue a timed break, though the host may override the + * timed break with a new timed break or a locked break. + */ + { +public: + enum TRequester + { + ENone, + EDevice, + EHost, + }; + + enum TState + { + EInactive, + ETiming, + ELocked, + ENumStates + }; + +public: + static CBreakController* NewL(CCdcAcmClass& aParentAcm); + ~CBreakController(); + +public: // API for requesting breaks + TInt BreakRequest(TRequester aRequester, + TState aState, + TTimeIntervalMicroSeconds32 aDelay = 0); + +private: + CBreakController(CCdcAcmClass& aParentAcm); + void ConstructL(); + +private: + void StateMachine(TState aBreakState, TTimeIntervalMicroSeconds32 aDelay); + + void Publish(TState aNewState); + + static TBool ScInvalid(CBreakController *aThis, + TTimeIntervalMicroSeconds32 aDelay); + static TBool ScInactive(CBreakController *aThis, + TTimeIntervalMicroSeconds32 aDelay); + static TBool ScSetTimer(CBreakController *aThis, + TTimeIntervalMicroSeconds32 aDelay); + static TBool ScLocked(CBreakController *aThis, + TTimeIntervalMicroSeconds32 aDelay); + +private: // from CActive + void RunL(); + void DoCancel(); + +private: // owned + typedef TBool ( *PBFNT ) (CBreakController *aThis, + TTimeIntervalMicroSeconds32 aDelay); + PBFNT StateDispatcher[ENumStates][ENumStates]; + RTimer iTimer; + TState iBreakState; + // Whoever's in charge of the current break. + TRequester iRequester; + +private: // unowned + CCdcAcmClass& iParentAcm; ///< use to tell (USB) Host about changes + }; + +#endif // __BREAKCONTROLLER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/BreakObserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/BreakObserver.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,40 @@ +/* +* 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: +* +*/ + +#ifndef __BREAKOBSERVER_H__ +#define __BREAKOBSERVER_H__ + +#include + +class MBreakObserver +/** + * Interface for notifications of break changes. + */ + { +public: + /** + * Called when an MBreakObserver-requested break has completed. + */ + virtual void BreakRequestCompleted() = 0; + /** + * Called when the break state has changed (i.e. it has been off and gone + * either timed or locked, or if it was on and has gone off). + */ + virtual void BreakStateChange() = 0; + }; + +#endif // __BREAKOBSERVER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/CdcAcmClass.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/CdcAcmClass.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,184 @@ +/* +* 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: +* +*/ + +#ifndef __CDCACMCLASS_H__ +#define __CDCACMCLASS_H__ + +#include +#include "CdcControlInterfaceRequestHandler.h" +#include "BreakController.h" + +class MHostPushedChangeObserver; +class MBreakObserver; +class MReadObserver; +class MReadOneOrMoreObserver; +class MNotifyDataAvailableObserver; +class MWriteObserver; +class CCdcControlInterface; +class CCdcDataInterface; + +NONSHARABLE_CLASS(CCdcAcmClass) : public CBase, + public MCdcCommsClassRequestHandler +/** + * The Communication Device Class Abstract Control Model class. + * This class owns and controls the classes that handle the ACM data and + * control interfaces. + * Instantiation of this class instantiates an ACM function. + */ + { +public: + enum TUsbParity ///< Serial port emulated parity setting. Taken directly + // from the spec. + { + EUsbParityNone = 0, + EUsbParityOdd = 1, + EUsbParityEven = 2, + EUsbParityMark = 3, + EUsbParitySpace = 4 + }; + + enum TUsbStopBits ///< Serial port emulated stop bit setting. Taken + // directly from the spec. + { + EUsbStopBitOne = 0, + EUsbStopBitOnePtFive = 1, + EUsbStopBitTwo = 2 + }; + + enum TUsbDataBits ///< Serial port emulated data bit setting. Taken + // directly from the spec. + { + EUsbDataBitsFive = 5, + EUsbDataBitsSix = 6, + EUsbDataBitsSeven = 7, + EUsbDataBitsEight = 8, + EUsbDataBitsSixteen = 16 + }; + + enum TUsbCommFeatureSelector + { + EUsbCommFeatureSelectAbstractState = 0x01, + EUsbCommFeatureSelectCountryCode = 0x02 + }; + + enum TUsbAbstractStateBits + { + EUsbAbstractStateNoBits = 0x0000, + EUsbAbstractStateIdleSetting = 0x0001, + EUsbAbstractStateDataMultiplex = 0x0002 + }; + + NONSHARABLE_CLASS(TUsbConfig) ///< Serial port emulated configuration + { + public: + TUint iChangedMembers; + TUint32 iRate; ///< The line rate + TUsbDataBits iDataBits; ///< The number of data bits + TUsbStopBits iStopBits; ///< The number of stop bits + TUsbParity iParity; ///< The parity + }; + +public: + static CCdcAcmClass* NewL(const TUint8 aProtocolNum, const TDesC16& aAcmControlIfcName, const TDesC16& aAcmDataIfcName); + ~CCdcAcmClass(); + +public: + void SetCallback(MHostPushedChangeObserver* aCallback); + void SetBreakCallback(MBreakObserver* aBreakCallback); + void Read(MReadObserver& aObserver, TDes8 &aDes); + void Read(MReadObserver& aObserver, TDes8 &aDes,TInt aLength); + void ReadOneOrMore(MReadOneOrMoreObserver& aObserver, TDes8 &aDes); + void ReadOneOrMore(MReadOneOrMoreObserver& aObserver, TDes8 &aDes, TInt aLength); + void ReadCancel(); + void NotifyDataAvailable(MNotifyDataAvailableObserver& aObserver); + void NotifyDataAvailableCancel(); + + void Write(MWriteObserver& aObserver, const TDesC8& aDes); + void Write(MWriteObserver& aObserver, const TDesC8& aDes, TInt aLength); + void WriteCancel(); + + TInt SendSerialState(TBool aRing, TBool aDsr, TBool aDcd); + +public: // API for requesting a timed or locked break, and for turning the + // break off. + TInt BreakRequest(CBreakController::TRequester aRequester, + CBreakController::TState aState, + TTimeIntervalMicroSeconds32 aDelay = 0); + +public: // used by the break controller + TBool RingState() const; + TBool DsrState() const; + TBool DcdState() const; + + // Accessor for break state + TBool BreakActive() const; + void SetBreakActive(TBool aBreakActive); + + MHostPushedChangeObserver* Callback(); + MBreakObserver* BreakCallback(); + +private: + CCdcAcmClass(); + void ConstructL(const TUint8 aProtocolNum); + void ConstructL(const TUint8 aProtocolNum, const TDesC16& aControlIfcName, const TDesC16& aDataIfcName); + +private: // from MCdcCommsClassRequestHandler + virtual TInt HandleSendEncapCommand(const TDesC8& aData); + virtual TInt HandleGetEncapResponse(TDes8& aReturnData); + virtual TInt HandleSetCommFeature(const TUint16 aSelector, + const TDes8& aData); + virtual TInt HandleGetCommFeature(const TUint16 aSelector, + TDes8& aReturnData); + virtual TInt HandleClearCommFeature(const TUint16 aSelector); + virtual TInt HandleSetLineCoding(const TDesC8& aData); + virtual TInt HandleGetLineCoding(TDes8& aReturnData); + virtual TInt HandleSetControlLineState(TBool aRtsState,TBool aDtrState); + virtual TInt HandleSendBreak(TUint16 aDuration); + +private: // utility + void SetDefaultAcm(void); + static void ConvertUsbConfigCodingToEpoc(const TUsbConfig& aUsbConfig, + TCommConfigV01& aEpocConfig); + TInt HandleNewAbstractState(const TUint16 aAbstractState); + TInt HandleNewCountryCode(const TUint16 aCountryCode); + +private: // unowned + MHostPushedChangeObserver* iCallback; + MBreakObserver* iBreakCallback; + +private: // owned + CBreakController* iBreakController; ///< The BREAK state machine + CCdcControlInterface* iControl; ///< The control interface + CCdcDataInterface* iData; ///< The data interface + + TUint16 iAcmState; ///< The multiplexed and idle state + TUint16 iCountryCode; ///< The country code from ISO 3166 + TUsbConfig iUsbConfig; ///< The USB Configuration + TBool iRtsState; ///< The emulated RTS state + TBool iDtrState; ///< The eumlated DTR state + + TBool iAcmDataMultiplex; ///< derived from bit D1 of iACMState + TBool iAcmIdleSetting; ///< derived from bit D0 of iACMState + + TBool iRingState; ///< Saved RING state + TBool iDsrState; ///< Saved DSR state + TBool iDcdState; ///< Saved DCD state + + TBool iBreakActive; ///< Locally controlled BREAK state + }; + +#endif // __CDCACMCLASS_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/CdcControlInterface.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/CdcControlInterface.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,87 @@ +/* +* 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: +* +*/ + +#ifndef __CDCCONTROLINTERFACE_H__ +#define __CDCCONTROLINTERFACE_H__ + +#include "CdcInterfaceBase.h" + +class CCdcAcmClass; +class CCdcControlInterfaceReader; + +NONSHARABLE_CLASS(CCdcControlInterface) : public CCdcInterfaceBase +/** + * ACM control interface subclass. + */ + { +public: + static CCdcControlInterface* NewL(CCdcAcmClass& aParent, const TUint8 aProtocolNum, const TDesC16& aIfcName); + ~CCdcControlInterface(); + +public: + TInt SetupClassSpecificDescriptor(TUint8 aDataInterfaceNumber); + TInt SendNetworkConnection(TBool aValue); + TInt SendSerialState(TBool aOverRun, + TBool aParity, + TBool aFraming, + TBool aRing, + TBool aBreak, + TBool aTxCarrier, + TBool aRxCarrier); + +public: + static inline TReal32 GetF32( TUint8** aPPbuf ); + static inline void PutF32( TUint8** aPPbuf, TReal32 aF32 ); + + static inline TUint32 GetU32( TUint8** aPPbuf ); + static inline void PutU32( TUint8** aPPbuf, TUint32 aU32 ); + + static inline TUint16 GetU16( TUint8** aPPbuf ); + static inline void PutU16( TUint8** aPPbuf,TUint16 aU16 ); + + static inline TUint8 GetU08( TUint8** aPPbuf ); + static inline void PutU08( TUint8** aPPbuf, TUint8 aU8 ); + +private: + CCdcControlInterface(const TUint8 aProtocolNum, const TDesC16& aIfcName); + void ConstructL(CCdcAcmClass& aParent); + +private: // from CCdcClassBase + TInt SetUpInterface(); + +private: // utility + TInt WriteData(TEndpointNumber aEndPoint, TDes8& aDes, TInt aLength); + +private: // owned + CCdcControlInterfaceReader* iReader; ///< Handle on the read object + + TUint16 iSerialState; ///< local copy of the flagset + const TUint8 iProtocolNum; + + enum + { + ///< Max packet size sent on Interrupt endpoint + KMaxPacketTypeInterrupt = 64, + ///< Interrupt endpoint poll time in ms + KPollInterval = 128, + KWriteDataTimeout = 500000, + }; + }; + +#include "LittleEndianPacker.INL" + +#endif // __CDCCONTROLINTERFACE_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/CdcControlInterfaceReader.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/CdcControlInterfaceReader.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,94 @@ +/* +* 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: +* +*/ + +#ifndef __CDCCONTROLINTERFACEREADER_H__ +#define __CDCCONTROLINTERFACEREADER_H__ + +#include +#include "RequestHeader.h" +#include "acmcapability.h" + +class MCdcCommsClassRequestHandler; +class RDevUsbcClient; + +NONSHARABLE_CLASS(CCdcControlInterfaceReader) : public CActive +/** + * Deals with reading control information from the LDD. + */ + { +public: + static CCdcControlInterfaceReader* NewL( + MCdcCommsClassRequestHandler& aParent, + RDevUsbcClient& aLdd); + ~CCdcControlInterfaceReader(); + +private: + CCdcControlInterfaceReader(MCdcCommsClassRequestHandler& aParent, + RDevUsbcClient& aLdd); + +private: // utility + void HandleReadCompletion(TInt aError); + + void DecodeMessageHeader(); + void DecodeMessageDataWithResponseRequired(); + void DecodeMessageData(); + + void ReadMessageHeader(); + void ReadMessageData(TUint aLength); + +private: // from CActive + void RunL(); + void DoCancel(); + +private: // unowned + MCdcCommsClassRequestHandler& iParent; + RDevUsbcClient& iLdd; + +private: // owned + TBuf8 iMessageHeader; ///< Raw message header + + enum + { + KAcmControlReadBufferLength = 256, ///< Size of the ACM control read + ///< buffer + + // Request IDs- see p16 of UBSCDC1.1 Table 4. + KGetEncapsulated = 0x01, ///< GET_ENCAPSULATED_RESPONSE + KGetCommFeature = 0x03, ///< GET_COMM_FEATURE + KGetLineCoding = 0x21, ///< GET_LINE_CODING + + KSendEncapsulated = 0x00, ///< SEND_ENCAPSULATED_COMMAND + KSetCommFeature = 0x02, ///< SET_COMM_FEATURE + KClearCommFeature = 0x04, ///< CLEAR_COMM_FEATURE + KSetLineCoding = 0x20, ///< SET_LINE_CODING + KSetControlLineState = 0x22, ///< SET_CONTROL_LINE_STATE + KSendBreak = 0x23, ///< SEND_BREAK + }; + + enum TReaderState + { + EWaitingForHeader = 0, ///< Waiting for message header + EWaitingForData = 1, ///< Waiting for message data + }; + + TBuf8 iMessageData; ///< Message data + ///< Decoded message header + TUsbRequestHdr iRequestHeader; + TReaderState iState; ///< Reader state + }; + +#endif // __CDCCONTROLINTERFACEREADER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/CdcControlInterfaceRequestHandler.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/CdcControlInterfaceRequestHandler.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,84 @@ +/* +* 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: +* +*/ + +#ifndef __CDCCOMMSCLASSREQUESTHANDLER_H__ +#define __CDCCOMMSCLASSREQUESTHANDLER_H__ + +#include + +class MCdcCommsClassRequestHandler +/** + * Interface for control interface requests from the host. Called by the + * reader on the control endpoint (ep0) when it decodes a relevant command. + */ + { +public: +/** + * Callback for Send Encap Command requests + * @param aData Message data. + */ + virtual TInt HandleSendEncapCommand(const TDesC8& aData) = 0; +/** + * Callback for Get Encapsulated Response requests + * @param aReturnData Message data. + */ + virtual TInt HandleGetEncapResponse(TDes8& aReturnData) = 0; +/** + * Callback for Set Comm Feature requests + * @param aSelector The source of wValue control over feature selection + * @param aData The multiplexed data/idle state or country code from ISO 3166 + */ + virtual TInt HandleSetCommFeature(const TUint16 aSelector, + const TDes8& aData) = 0; +/** + * Callback for Get Comm Feature requests + * @param aSelector The source of wValue control over feature selection + * @param aReturnData The multiplexed data/idle state or country code from ISO + * 3166 + */ + virtual TInt HandleGetCommFeature(const TUint16 aSelector, + TDes8& aReturnData) = 0; +/** + * Callback for Clear Comm Feature requests + * @param aSelector + */ + virtual TInt HandleClearCommFeature(const TUint16 aSelector) = 0; +/** + * Callback for Set Line Coding requests + * @param aData Message data. + */ + virtual TInt HandleSetLineCoding(const TDesC8& aData) = 0; +/** + * Callback for Get Line Coding requests + * @param aReturnData Message data. + */ + virtual TInt HandleGetLineCoding(TDes8& aReturnData) = 0; +/** + * Callback for Set Control Line State requests + * @param aRtsState RTS state. + * @param aDtrState DTR state. + */ + virtual TInt HandleSetControlLineState(TBool aRtsState, + TBool aDtrState) = 0; +/** + * Callback for Send Break requests + * @param aDuration Duration of the break in microseconds + */ + virtual TInt HandleSendBreak(TUint16 aDuration) = 0; + }; + +#endif // __CDCCOMMSCLASSREQUESTHANDLER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/CdcDataInterface.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/CdcDataInterface.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,126 @@ +/* +* 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: +* +*/ + +#ifndef __CDCDATAINTERFACE_H__ +#define __CDCDATAINTERFACE_H__ + +#include "CdcInterfaceBase.h" +#include "WriteObserver.h" +#include "ReadObserver.h" +#include "ReadOneOrMoreObserver.h" +#include "linkstatenotifier.h" +#include "NotifyDataAvailableObserver.h" + + + +class CActiveReadOneOrMoreReader; +class CActiveReader; +class CActiveDataAvailableNotifier; +class CActiveWriter; +class CIniFile; + +NONSHARABLE_CLASS(CCdcDataInterface) : public CCdcInterfaceBase, + public MReadObserver, + public MReadOneOrMoreObserver, + public MWriteObserver, + public MLinkStateObserver, + public MNotifyDataAvailableObserver +/** + * ACM data interface subclass. + */ + { +public: + static CCdcDataInterface* NewL(const TDesC16& aIfcName); + ~CCdcDataInterface(); + +public: + void Write(MWriteObserver& aObserver, const TDesC8& aDes, TInt aLen); + void CancelWrite(); + void Read(MReadObserver& aObserver, TDes8& aDes, TInt aMaxLen); + void ReadOneOrMore(MReadOneOrMoreObserver& aObserver, + TDes8 &aDes, + TInt aMaxLen); + void CancelRead(); + void NotifyDataAvailable(MNotifyDataAvailableObserver& aObserver); + void CancelNotifyDataAvailable(); + +private: + CCdcDataInterface(); + CCdcDataInterface(const TDesC16& aIfcName); + void ConstructL(); + +private: // from MReadOneOrMoreObserver + void ReadOneOrMoreCompleted(TInt aError); + +private: // from MReadObserver + void ReadCompleted(TInt aError); + +private: // from MWriteObserver + void WriteCompleted(TInt aError); + +private: // from CCdcClassBase + TInt SetUpInterface(); + +private: // from MLinkStateObserver + void MLSOStateChange(TInt aPacketSize); + +private: // from MNotifyDataAvailableObserver + void NotifyDataAvailableCompleted(TInt aError); + +private: + void GetHostZLPHandlingFromFile(); + +private: // owned + CActiveReadOneOrMoreReader* iReadOneOrMoreReader; + CActiveReader* iReader; + CActiveWriter* iWriter; + CActiveDataAvailableNotifier* iDataAvailableNotifier; + CLinkStateNotifier* iLinkState; + TBool iHostCanHandleZLPs; ///< Host USB Device Driver can cope with Zero Length Packets + TInt iPacketSize; + +private: // unowned + MReadObserver* iReadObserver; + MReadOneOrMoreObserver* iReadOneOrMoreObserver; + MWriteObserver* iWriteObserver; + MNotifyDataAvailableObserver* iNotifyDataAvailableObserver; + +#ifdef __HEADLESS_ACM_TEST_CODE__ + // This code is for testing the performance of the stack at the + // RDevUsbcClient level. Issue a Read or ReadOneOrMore at the RComm level, + // and it will be passed to the LDD. When it completes, it will Write the + // data back. When that completes, it will again Read/ROOM. It basically + // enters an infinite loop, doing loopback. Drive this from the PC end + // using serial.exe. +private: // owned + // The buffer to do repeated Read/ReadOneOrMore into and Writes from. + TBuf8<4096> iHeadlessAcmBuffer; + // The length of the initial Read/ROOM request- we continue to use this + // value in subsequent Read/ROOM requests. + TUint iHeadlessReadLength; + // Whether we're currently using Read or ROOM. + enum THeadlessReadType + { + EUnknown, + ERead, + EReadOneOrMore + }; + THeadlessReadType iHeadlessReadType; +#endif // __HEADLESS_ACM_TEST_CODE__ + }; + +#endif // __CDCDATAINTERFACE_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/CdcInterfaceBase.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/CdcInterfaceBase.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,47 @@ +/* +* 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: +* +*/ + +#ifndef __CDCINTERFACEBASE_H__ +#define __CDCINTERFACEBASE_H__ + +#include +#include + +NONSHARABLE_CLASS(CCdcInterfaceBase) : public CBase +/** + * Base class for ACM interface subclasses. + */ + { +public: + ~CCdcInterfaceBase(); + +public: + TInt GetInterfaceNumber(TUint8& aIntNumber); + +protected: + CCdcInterfaceBase(const TDesC16& aIfcName); + void BaseConstructL(); + +private: + virtual TInt SetUpInterface() = 0; + +protected: // owned + RDevUsbcClient iLdd; ///< The Ldd to use. + TPtrC16 iIfcName; + }; + +#endif // __CDCINTERFACEBASE_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ClassDescriptor.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ClassDescriptor.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,81 @@ +/* +* 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: +* +*/ + +#ifndef __CLASSDESCRIPTOR_H__ +#define __CLASSDESCRIPTOR_H__ + +#include +#include "acmcapability.h" + +#ifdef DISABLE_ACM_CF_COUNTRY_SETTING + + const TUint KUSBClassSpecificBufferSize = 14; + +#elif defined ENABLE_ACM_CF_COUNTRY_SETTING + + const TUint KUsbCommNumCountries = 1; + const TUint16 KUsbCommCountryCode0 = (('G'<<8)+'B'); + const TUint KUSBClassSpecificBufferSize = 18 + (2*KUsbCommNumCountries); + +#endif + +NONSHARABLE_CLASS(TUsbCsClassDescriptor) ///< Class-specific descriptor + { +public: + TUint8 iHdrSize; ///< Header size + TUint8 iHdrType; ///< Type + TUint8 iHdrSubType; ///< Sub-type + TUint16 iHdrBcdCDC; ///< CDC version no in binary coded decimal + TUint8 iAcmSize; ///< ACM descriptor size + TUint8 iAcmType; ///< ACM type + TUint8 iAcmSubType; ///< ACM sub-type + TUint8 iAcmCapabilities; ///< ACM capabilities + TUint8 iUnSize; ///< Union descriptor size + TUint8 iUnType; ///< Union descriptor type + TUint8 iUnSubType; ///< Union descriptor sub-type + TUint8 iUnMasterInterface; ///< Master interface number + TUint8 iUnSlaveInterface; ///< Slave interface number + +#if defined(DISABLE_ACM_CF_COUNTRY_SETTING) + + // no functional descriptor needed + +#elif defined(ENABLE_ACM_CF_COUNTRY_SETTING) + + // CDC Country Selection Functional Descriptor + TUint8 iCsSize; ///< Country Selection descriptor size + TUint8 iCsType; ///< Country Selection descriptor type + TUint8 iCsSubType; ///< Country Selection descriptor sub-type + TUint8 iCsRelDate; ///< Country Selection (string ddmmyyyy) ISO-3166 date + TUint16 iCsCountryCode[KUsbCommNumCountries]; + +#endif + +public: + TDes8& Des(); + +private: + enum + { + ///< Size of the ACM class-specific descriptor + KUsbClassSpecificBufferSize = 14, + }; + + TBuf8 iBuffer; + }; + +#endif // __CLASSDESCRIPTOR_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/HostPushedChangeObserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/HostPushedChangeObserver.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,35 @@ +/* +* 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: +* +*/ + +#ifndef __HOSTPUSHEDCHANGEOBSERVER_H__ +#define __HOSTPUSHEDCHANGEOBSERVER_H__ + +#include +#include + +class MHostPushedChangeObserver +/** + * The CSY callback interface. This class provides methods that enable the ACM + * class to inform the CSY of changes pushed by the host. + */ + { +public: + virtual void HostConfigChange(const TCommConfigV01& aConfig) = 0; + virtual void HostSignalChange(TBool aDtr, TBool aRts) = 0; + }; + +#endif // __HOSTPUSHEDCHANGEOBSERVER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/LittleEndianPacker.INL --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/LittleEndianPacker.INL Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,136 @@ +/* +* 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: +* +*/ + +/** file LittleEndianPacker.INL + * + * Implements inline macro functions used to interface between USB + * (little-endian) byte buffers and standard data types. + * + * The implementation uses inline macros (for speed) that are used to + * step down a little-endian USB buffer to extract and insert members. + * + * The functions update the given buffer index so that they can be + * used in sequence to extract or pack successive parts of a message. + * + * Although these functions are of more general use than just the CDC + * application, they are located here pending possible promotion into + * the chapter.9 area, where they would become available for use in + * other classes, e.g. HID + * + * Copyright (c) 2003 Symbian Ltd. All rights reserved. + */ + +#ifndef __LITTLEENDIANPACKER_INL__ +#define __LITTLEENDIANPACKER_INL__ + +#include + +/* ------------------------------------------------------------------------- */ + +typedef union _FloatInt + { + TUint32 uVal; + TReal32 fVal; + } + UFloatInt; + +inline TReal32 CCdcControlInterface::GetF32( TUint8** aPPbuf ) + { + UFloatInt retval; + + retval.uVal = GetU32(aPPbuf); + + return retval.fVal; + }; + +inline void CCdcControlInterface::PutF32( TUint8** aPPbuf, TReal32 aF32 ) + { + UFloatInt inval; + + inval.fVal = aF32; + + PutU32(aPPbuf,inval.uVal); + }; + +/* ------------------------------------------------------------------------- */ + +inline TUint32 CCdcControlInterface::GetU32( TUint8** aPPbuf ) + { + TUint8* pbuf = *aPPbuf; + + *aPPbuf = pbuf + sizeof(TUint32); + + return (TUint32)( (pbuf[3] << 24 ) | ( pbuf[2] << 16 ) | ( pbuf[1] << 8 ) | ( pbuf[0] ) ); + }; + +inline void CCdcControlInterface::PutU32( TUint8** aPPbuf, TUint32 aU32 ) + { + TUint8* pbuf = *aPPbuf; + + *aPPbuf = pbuf + sizeof(TUint32); + + pbuf[3] = (TUint8) ((aU32 >> 24) ); // mask not needed, only 8 bits left + pbuf[2] = (TUint8) ((aU32 >> 16) & 0xFF); + pbuf[1] = (TUint8) ((aU32 >> 8) & 0xFF); + pbuf[0] = (TUint8) ((aU32 ) & 0xFF); // shift not needed, mask takes 8 bits + }; + +/* ------------------------------------------------------------------------- */ + +inline TUint16 CCdcControlInterface::GetU16( TUint8** aPPbuf ) + { + TUint8* pbuf = *aPPbuf; + + *aPPbuf = pbuf + sizeof(TUint16); + + return (TUint16) ( ( pbuf[1] << 8) | ( pbuf[0] ) ); + }; + +inline void CCdcControlInterface::PutU16( TUint8** aPPbuf, TUint16 aU16 ) + { + TUint8* pbuf = *aPPbuf; + + *aPPbuf = pbuf + sizeof(TUint16); + + pbuf[3] = (TUint8) ((aU16 >> 8) ); // mask not needed, only 8 bits left + pbuf[0] = (TUint8) ((aU16 ) & 0xFF); // shift not needed, mask takes 8 bits + }; + +/* ------------------------------------------------------------------------- */ + +inline TUint8 CCdcControlInterface::GetU08( TUint8** aPPbuf ) + { + TUint8* pbuf = *aPPbuf; + + *aPPbuf = pbuf + sizeof(TUint8); + + return (TUint8) ( pbuf[0] ); + }; + +inline void CCdcControlInterface::PutU08( TUint8** aPPbuf, TUint8 aU8 ) + { + TUint8* pbuf = *aPPbuf; + + *aPPbuf = pbuf + sizeof(TUint8); + + pbuf[0] = (aU8); + }; + +/* ------------------------------------------------------------------------- */ +#endif // __LITTLEENDIANPACKER_INL__ +/* ------------------------------------------------------------------------- */ + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/NotifyDataAvailableObserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/NotifyDataAvailableObserver.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,32 @@ +/* +* Copyright (c) 2007-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: +* +*/ + +#ifndef __NOTIFYDATAAVAILABLEOBSERVER_H__ +#define __NOTIFYDATAAVAILABLEOBSERVER_H__ + +#include + +class MNotifyDataAvailableObserver +/** + * Notification that data is available to be read from the device driver. + */ + { +public: + virtual void NotifyDataAvailableCompleted(TInt aError) = 0; + }; + +#endif // __NOTIFYDATAAVAILABLEOBSERVER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ReadObserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ReadObserver.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,33 @@ +/* +* 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: +* +*/ + +#ifndef __READOBSERVER_H__ +#define __READOBSERVER_H__ + +#include + +class MReadObserver +/** + * An interface for notification of read completions. + */ + { +public: + virtual void ReadCompleted(TInt aError) = 0; + }; + + +#endif // __READOBSERVER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ReadOneOrMoreObserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/ReadOneOrMoreObserver.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,32 @@ +/* +* 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: +* +*/ + +#ifndef __READONEORMOREOBSERVER_H__ +#define __READONEORMOREOBSERVER_H__ + +#include + +class MReadOneOrMoreObserver +/** + * Interface for notifications of read one or more completions. + */ + { +public: + virtual void ReadOneOrMoreCompleted(TInt aError) = 0; + }; + +#endif // __READONEORMOREOBSERVER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/RegistrationPort.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/RegistrationPort.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,90 @@ +/* +* 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: +* +*/ + +#ifndef __REGISTRATIONPORT_H__ +#define __REGISTRATIONPORT_H__ + +#include + +class MAcmController; + +/** +The registration port. +This is a deprecated method for controlling (bringing up and down) ACM +functions. +ACM Class Controllers open a registration port and use SetSignalsToMark and +SetSignalsToSpace to bring ACM functions up and down. +The newer method involved creating a session on the ACM server (RAcmServer) +and using the APIs provided. +*/ +NONSHARABLE_CLASS(CRegistrationPort) : public CPort + { +public: + static CRegistrationPort* NewL(MAcmController& aAcmController, + TUint aUnit); + ~CRegistrationPort(); + +private: + CRegistrationPort(MAcmController& aAcmController); + void ConstructL(TUint aUnit); + +private: // from CPort + virtual void StartRead(const TAny* aClientBuffer,TInt aLength); + virtual void ReadCancel(); + virtual TInt QueryReceiveBuffer(TInt& aLength) const; + virtual void ResetBuffers(TUint aFlags); + virtual void StartWrite(const TAny* aClientBuffer,TInt aLength); + virtual void WriteCancel(); + virtual void Break(TInt aTime); + virtual void BreakCancel(); + virtual TInt GetConfig(TDes8& aDes) const; + virtual TInt SetConfig(const TDesC8& aDes); + virtual TInt SetServerConfig(const TDesC8& aDes); + virtual TInt GetServerConfig(TDes8& aDes); + virtual TInt GetCaps(TDes8& aDes); + virtual TInt GetSignals(TUint& aSignals); + virtual TInt SetSignalsToMark(TUint aNoAcms); + virtual TInt SetSignalsToSpace(TUint aNoAcms); + virtual TInt GetReceiveBufferLength(TInt& aLength) const; + virtual TInt SetReceiveBufferLength(TInt aLength); + virtual void Destruct(); + virtual void FreeMemory(); + virtual void NotifySignalChange(TUint aSignalMask); + virtual void NotifySignalChangeCancel(); + virtual void NotifyConfigChange(); + virtual void NotifyConfigChangeCancel(); + virtual void NotifyFlowControlChange(); + virtual void NotifyFlowControlChangeCancel(); + virtual void NotifyBreak(); + virtual void NotifyBreakCancel(); + virtual void NotifyDataAvailable(); + virtual void NotifyDataAvailableCancel(); + virtual void NotifyOutputEmpty(); + virtual void NotifyOutputEmptyCancel(); + virtual TInt GetFlowControlStatus(TFlowControl& aFlowControl); + virtual TInt GetRole(TCommRole& aRole); + virtual TInt SetRole(TCommRole aRole); + +private: // unowned + MAcmController& iAcmController; + +private: // owned + // Dummy role of the serial port (DTE or DCE) + TCommRole iRole; + }; + +#endif // __REGISTRATIONPORT_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/RequestHeader.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/RequestHeader.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,43 @@ +/* +* 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: +* +*/ + +#ifndef __REQUESTHEADER_H__ +#define __REQUESTHEADER_H__ + +#include + +const TUint KUsbRequestHdrSize = 8; ///< Size of the request header + +NONSHARABLE_CLASS(TUsbRequestHdr) ///< Class-specific header structure + { +public: + TUint8 iRequestType; ///< Request type + TUint8 iRequest; ///< Request number + TUint16 iValue; ///< Request value + TUint16 iIndex; ///< Request index + TUint16 iLength; ///< Request length + +public: + static TInt Decode(const TDesC8& aBuffer, TUsbRequestHdr& aTarget); + const TDesC8& Des(); + TBool IsDataResponseRequired() const; + +private: + TBuf8 iBuffer; + }; + +#endif // __REQUESTHEADER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/WriteObserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/WriteObserver.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,33 @@ +/* +* 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: +* +*/ + +#ifndef __WRITEOBSERVER_H__ +#define __WRITEOBSERVER_H__ + +#include + +class MWriteObserver +/** + * An interface for notification of write completions. + */ + { +public: + virtual void WriteCompleted(TInt aError) = 0; + }; + + +#endif // __WRITEOBSERVER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/acmcapability.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/acmcapability.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,98 @@ +/* +* 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: +* Defines USB CDC Control Class supported feature subset +* +*/ + +/** + @file +*/ + +#ifndef __ACMCAPABILITY_H__ +#define __ACMCAPABILITY_H__ + +/** + * Country Code Selection ------------------------------- + */ +#undef ENABLE_ACM_CF_COUNTRY_SETTING +#define DISABLE_ACM_CF_COUNTRY_SETTING + +#if( defined(DISABLE_ACM_CF_COUNTRY_SETTING) && defined(ENABLE_ACM_CF_COUNTRY_SETTING) ) + + #error Country-Setting Feature Cannot be Both Enabled and Disabled + +#elif defined(DISABLE_ACM_CF_COUNTRY_SETTING) + + // feature is not present + +#elif defined(ENABLE_ACM_CF_COUNTRY_SETTING) + + // feature is present + +#else + + #error Uncontrolled Country-Setting Feature + +#endif + +/** + * Abstract State Selection (Idle) ---------------------- + */ +#undef ENABLE_ACM_CF_IDLE_SETTING +#define DISABLE_ACM_CF_IDLE_SETTING + +#if( defined(DISABLE_ACM_CF_IDLE_SETTING) && defined(ENABLE_ACM_CF_IDLE_SETTING) ) + + #error Abstract Idle Setting Feature Cannot be Both Enabled and Disabled + +#elif defined(DISABLE_ACM_CF_IDLE_SETTING) + + // feature is not present + +#elif defined(ENABLE_ACM_CF_IDLE_SETTING) + + // feature is present + +#else + + #error Uncontrolled Abstract Idle Setting Feature + +#endif + +/** + * Abstract State Selection (Multiplex) ----------------- + */ +#undef ENABLE_ACM_CF_DATA_MULTIPLEX +#define DISABLE_ACM_CF_DATA_MULTIPLEX + +#if( defined(DISABLE_ACM_CF_DATA_MULTIPLEX) && defined(ENABLE_ACM_CF_DATA_MULTIPLEX) ) + + #error Abstract Data Multiplex Feature Cannot be Both Enabled and Disabled + +#elif defined(DISABLE_ACM_CF_DATA_MULTIPLEX) + + // feature is not present + +#elif defined(ENABLE_ACM_CF_DATA_MULTIPLEX) + + // feature is present + +#else + + #error Uncontrolled Abstract Data Multiplex Feature + +#endif + +#endif // __ACMCAPABILITY_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/acmcontroller.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/acmcontroller.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,36 @@ +/* +* 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: +* +*/ + +#ifndef __ACMCONTROLLER_H__ +#define __ACMCONTROLLER_H__ + +#include + +class MAcmController + +/** + * Interface for bringing up and down ACM functions. + * Used by both the (deprecated) registration port method of controlling ACM + * functions, and by the 'ACM server' method. + */ + { +public: + virtual TInt CreateFunctions(const TUint aNoAcms, const TUint8 aProtocolNum, const TDesC& aAcmControlIfcName, const TDesC& aAcmDataIfcName) = 0; + virtual void DestroyFunctions(const TUint aNoAcms) = 0; + }; + +#endif // __ACMCONTROLLER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/acmserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/acmserver.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,50 @@ +/* +* Copyright (c) 2005-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: +* +*/ + +/** + @file + @internalComponent +*/ + +#ifndef ACMSERVER_H +#define ACMSERVER_H + +#include + +class MAcmController; + +/** +The ACM server class - this is created/owned by the ACM Port Factory. +Clients can use this server to create and destroy ACM functions. +*/ +NONSHARABLE_CLASS(CAcmServer) : public CPolicyServer + { +public: + static CAcmServer* NewL(MAcmController& aAcmController); + ~CAcmServer(); + +private: + CAcmServer(MAcmController& aAcmController); + +private: // from CPolicyServer + CSession2* NewSessionL(const TVersion &aVersion, const RMessage2& aMessage) const; + +private: // unowned + MAcmController& iAcmController; + }; + +#endif // ACMSERVER_H diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/acmserversecuritypolicy.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/acmserversecuritypolicy.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,70 @@ +/* +* Copyright (c) 2005-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: +* Server Security Policy definitions. +* +*/ + +/** + @file + @internalComponent +*/ + +#ifndef ACMSERVERSECURITYPOLICY_H +#define ACMSERVERSECURITYPOLICY_H + +#include +#include "acmserverconsts.h" + +/** ACM Server Security Policy Definition */ +const TUint KAcmServerRangeCount = 2; + +const TInt KAcmServerRanges[KAcmServerRangeCount] = + { + EAcmCreateAcmFunctions, /** pass */ + EAcmDestroyAcmFunctions + 1, /** fail (to KMaxTInt) */ + }; + +/** Index numbers into KAcmServerElements[] */ +const TInt KPolicyUsbsvr = 0; + +/** Mapping IPCs to policy element */ +const TUint8 KAcmServerElementsIndex[KAcmServerRangeCount] = + { + KPolicyUsbsvr, /** All (valid) APIs */ + CPolicyServer::ENotSupported, /** remainder of possible IPCs */ + }; + +/** Individual policy elements */ +const CPolicyServer::TPolicyElement KAcmServerElements[] = + { + { + // These caps are those of USBSVR's process. This is the recommended + // way to check that an API is called by a specific process only. [The + // alternative would be an SID check.] + _INIT_SECURITY_POLICY_C5(ECapabilityCommDD, ECapabilityNetworkControl, ECapabilityNetworkServices, ECapabilityLocalServices, ECapabilityProtServ), CPolicyServer::EFailClient + }, + }; + +/** Main policy */ +const CPolicyServer::TPolicy KAcmServerPolicy = + { + CPolicyServer::EAlwaysPass, /** Specifies all connect attempts should pass */ + KAcmServerRangeCount, + KAcmServerRanges, + KAcmServerElementsIndex, + KAcmServerElements, + }; + +#endif // ACMSERVERSECURITYPOLICY_H diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/acmsession.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/acmsession.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,51 @@ +/* +* Copyright (c) 2005-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: +* +*/ + +/** + @file + @internalComponent +*/ + +#ifndef ACMSESSION_H +#define ACMSESSION_H + +#include + +class MAcmController; + +NONSHARABLE_CLASS(CAcmSession) : public CSession2 + { +public: + static CAcmSession* NewL(MAcmController& aAcmController); + ~CAcmSession(); + +private: + CAcmSession(MAcmController& aAcmController); + void CreateFunctionsL(const RMessage2& aMessage); + +private: // from CSession2 + /** + Called when a message is received from the client. + @param aMessage Message received from the client. + */ + void ServiceL(const RMessage2& aMessage); + +private: // unowned + MAcmController& iAcmController; + }; + +#endif // ACMSESSION_H diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/linkstatenotifier.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/inc/linkstatenotifier.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,74 @@ +/* +* Copyright (c) 2006-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: +* +*/ + +#ifndef __LINKSTATENOTIFIER_H__ +#define __LINKSTATENOTIFIER_H__ + +#include + +class RDevUsbcClient; + + +const TInt KMaxPacketTypeBulkFS = 64; +const TInt KMaxPacketTypeBulkHS = 512; + +const TInt KDefaultMaxPacketTypeBulk = KMaxPacketTypeBulkFS; + + +class MLinkStateObserver +/** + * Interface for notifications of link state events. + */ + { +public: + virtual void MLSOStateChange(TInt aPacketSize) = 0; + }; + +NONSHARABLE_CLASS(CLinkStateNotifier) : public CActive +/** + * Active object to request link state notifications. + */ + { +public: + static CLinkStateNotifier* NewL(MLinkStateObserver& aParent, + RDevUsbcClient& aUsb); + ~CLinkStateNotifier(); + + void Start(); + +private: // from CActive + virtual void DoCancel(); + virtual void RunL(); + virtual TInt RunError(TInt aError); + +private: + CLinkStateNotifier(MLinkStateObserver& aParent, RDevUsbcClient& aUsb); + +private: + void LinkUp(); + void LinkDown(); + +private: // unowned + MLinkStateObserver& iParent; ///< Observer + RDevUsbcClient& iUsb; ///< The Ldd to use + +private: // owned + TUint iUsbState; ///< Bitmask representing the endpoints + TInt iPacketSize; + }; + +#endif // __LINKSTATENOTIFIER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/public/AcmConfig.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/public/AcmConfig.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,126 @@ +/* +* Copyright (c) 2007-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: +* +*/ + +/** + @file + @publishedPartner + @released +*/ + +#ifndef __ACMCONFIG_H__ +#define __ACMCONFIG_H__ + +#include + +/** +Constant to use as the key when subscribing to the ACM function +configuration data. +*/ +static const TInt32 KAcmKey = 0x1028577C; + +/** +Structure describing the ACM function configuration +*/ +NONSHARABLE_STRUCT(TAcmConfig) + { + /** + iProtocol + iProtocol is the only field used at this time. Stores the protocol + that this AcmFunction was created to use. + */ + TUint8 iProtocol; + /** + Reserved for future use + */ + TInt8 iReserved8Bit1; + /** + Reserved for future use + */ + TInt8 iReserved8Bit2; + /** + Reserved for future use + */ + TInt8 iReserved8Bit3; + /** + Reserved for future use + */ + TInt32 iReserved1; + /** + Reserved for future use + */ + TInt32 iReserved2; + /** + Reserved for future use + */ + TInt32 iReserved3; + /** + Reserved for future use + */ + TInt32 iReserved4; + }; + +/** +Structure to hold TAcmConfig structs and publish all available +configurations in a single wrapper. +*/ +NONSHARABLE_STRUCT(TPublishedAcmConfigs) + { + /** + Constant to define the maximum number of ACM functions it should + be possible to create. Used to calculate the size of the byte + array to allocate when publishing the data. + */ + static const TInt16 KAcmMaxFunctions = 8; + + /** + iAcmConfigVersion + Version 1 is the only valid version at this time. + */ + TUint iAcmConfigVersion; + /** + iAcmCount + iAcmCount defines number of valid AcmConfigs in sequence. Only AcmConfigs + with an array index < AcmCount are valid. If iAcmCount == 0 then there + are no valid AcmConfigs at this time. + */ + TUint iAcmCount; + + /** + iAcmConfig + Array of TAcmConfig structs to hold the available Acm configurations + */ + TAcmConfig iAcmConfig[KAcmMaxFunctions]; + + /** + Reserved for future use + */ + TInt32 iReserved1; + /** + Reserved for future use + */ + TInt32 iReserved2; + /** + Reserved for future use + */ + TInt32 iReserved3; + /** + Reserved for future use + */ + TInt32 iReserved4; + }; + +#endif //__ACMCONFIG_H__ \ No newline at end of file diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/public/AcmInterface.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/public/AcmInterface.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,60 @@ +/* +* 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: +* +*/ + +#ifndef __ACMINTERFACE_H__ +#define __ACMINTERFACE_H__ + +/** @file +Public interface to ECACM CSY. +@publishedPartner +@released +*/ + +#include + +/** +The root of the CSY filename. Use this in LoadCommModule. +*/ +_LIT(KAcmCsyName, "ECACM"); + +/** +The name of the CSerial, and consequently the root of the ACM port name +ACM::0. Use this in Open (and UnloadCommModule, if you're not closing your +session anyway). +*/ +_LIT(KAcmSerialName, "ACM"); + +/** +Lowest valid value of %d in calls to Open(_L("ACM::%d")). +For the highest valid value of %d in calls to Open(_L("ACM::%d")), use RCommServ::GetPortInfo. +Note that if USB services are stopped/idle (see RUsb::GetServiceState) the high unit value will +be incorrect. Under these circumstances, no ACM ports are may be opened, but TSerialInfo cannot +express this. +When USB services are starting/started/stopping, the given high unit will accurately reflect +the highest available port number. Note that this numerical value will depend on the current +USB personality (see RUsb) and also potentially whether USB is fully started or in a transitional +state (starting or stopping). +*/ +const TUint KAcmLowUnit = 0; + +/** +@deprecated RCommServ::GetPortInfo is the preferred method for determining the number of available ports. +@see RCommServ::GetPortInfo +*/ +const TUint KAcmHighUnit = 0; + +#endif // __ACMINTERFACE_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/public/acmserverconsts.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/public/acmserverconsts.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,70 @@ +/* +* Copyright (c) 2005-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: +* +*/ + +/** + @file + @internalComponent +*/ + +#ifndef ACMSERVERCONSTS_H +#define ACMSERVERCONSTS_H + +#include + +_LIT(KAcmServerName, "!AcmSrv"); + +/** Version numbers. */ +const TInt8 KAcmSrvMajorVersionNumber = 1; +const TInt8 KAcmSrvMinorVersionNumber = 1; +const TInt16 KAcmSrvBuildNumber = 0; + +/** IPC messages supported by the server. */ +enum TAcmIpc + { + EAcmCreateAcmFunctions = 0, // the 1st message must be 0 for CPolicyServer to start up + EAcmDestroyAcmFunctions = 1, + }; + +/** Panic category with which the ACM server panics the client. */ +_LIT(KAcmSrvPanic,"ACMServer"); + +/** Panic codes with which the ACM server panics the client. */ +enum TAcmSvrPanic + { + /** The client has sent a bad IPC message number. */ + EAcmBadAcmMessage = 0, + }; + +/** +Default protocol number for ACM ports. Taken from USBCDC 1.1 Table 17 +@internalTechnology +*/ +const TUint8 KDefaultAcmProtocolNum = 0x01; // Hayes compatible modem + +/** +Default control interface name for ACM ports. +@internalTechnology +*/ +_LIT16(KControlIfcName, "CDC Comms Interface"); + +/** +Default data interface name for ACM ports. +@internalTechnology +*/ +_LIT16(KDataIfcName, "CDC Data Interface"); + +#endif // ACMSERVERCONSTS_H diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/AcmPort.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/AcmPort.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,1654 @@ +/* +* 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: +* +*/ + +#include +#include +#include "AcmPort.h" +#include "AcmPortFactory.h" +#include "AcmUtils.h" +#include "AcmWriter.h" +#include "AcmReader.h" +#include "AcmPanic.h" + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +const TUint KCapsRate=( KCapsBps50 + | KCapsBps75 + | KCapsBps110 + | KCapsBps134 + | KCapsBps150 + | KCapsBps300 + | KCapsBps600 + | KCapsBps1200 + | KCapsBps1800 + | KCapsBps2000 + | KCapsBps2400 + | KCapsBps3600 + | KCapsBps4800 + | KCapsBps7200 + | KCapsBps9600 + | KCapsBps19200 + | KCapsBps38400 + | KCapsBps57600 + | KCapsBps115200 + | KCapsBps230400 + | KCapsBps460800 + | KCapsBps576000 + | KCapsBps115200 + | KCapsBps4000000 ); +const TUint KCapsDataBits=KCapsData8; +const TUint KCapsStopBits=KCapsStop1; +const TUint KCapsParity=KCapsParityNone; +const TUint KCapsHandshaking=( + KCapsSignalCTSSupported + | KCapsSignalDSRSupported + | KCapsSignalRTSSupported + | KCapsSignalDTRSupported); +const TUint KCapsSignals=( + KCapsSignalCTSSupported + | KCapsSignalDSRSupported + | KCapsSignalRTSSupported + | KCapsSignalDTRSupported); +const TUint KCapsFifo = 0; +const TUint KCapsSIR = 0; ///< Serial Infrared capabilities +const TUint KCapsNotification = KNotifySignalsChangeSupported; +const TUint KCapsRoles = 0; +const TUint KCapsFlowControl = 0; + +const TBps KDefaultDataRate = EBps115200; +const TDataBits KDefaultDataBits = EData8; +const TParity KDefaultParity = EParityNone; +const TStopBits KDefaultStopBits = EStop1; +const TUint KDefaultHandshake = 0; +///< Default XON character is Q +const TText8 KDefaultXon = 17; +///< Default XOFF character is S +const TText8 KDefaultXoff = 19; + +// Starting size of each of the receive and transmit buffers. +const TUint KDefaultBufferSize = 0x1000; + +CAcmPort* CAcmPort::NewL(const TUint aUnit, MAcmPortObserver& aFactory) +/** + * Make a new CPort for the comm server + * + * @param aFactory The observer of the port, to be notified when the port + * closes. + * @param aUnit The port number. + * @return Ownership of a newly created CAcmPort object + */ + { + LOG_STATIC_FUNC_ENTRY + + CAcmPort* self = new(ELeave) CAcmPort(aUnit, aFactory); + CleanupClosePushL(*self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +void CAcmPort::ConstructL() +/** + * Standard second phase constructor. Create owned classes and initialise the + * port. + */ + { + iReader = CAcmReader::NewL(*this, KDefaultBufferSize); + iWriter = CAcmWriter::NewL(*this, KDefaultBufferSize); + + TName name; + name.Num(iUnit); + LEAVEIFERRORL(SetName(&name)); + + iCommServerConfig.iBufFlags = 0; + iCommServerConfig.iBufSize = iReader->BufSize(); + + iCommConfig.iRate = KDefaultDataRate; + iCommConfig.iDataBits = KDefaultDataBits; + iCommConfig.iParity = KDefaultParity; + iCommConfig.iStopBits = KDefaultStopBits; + iCommConfig.iHandshake = KDefaultHandshake; + iCommConfig.iParityError = 0; + iCommConfig.iFifo = 0; + iCommConfig.iSpecialRate = 0; + iCommConfig.iTerminatorCount= 0; + iCommConfig.iXonChar = KDefaultXon; + iCommConfig.iXoffChar = KDefaultXoff; + iCommConfig.iParityErrorChar= 0; + iCommConfig.iSIREnable = ESIRDisable; + iCommConfig.iSIRSettings = 0; + } + +CAcmPort::CAcmPort(const TUint aUnit, MAcmPortObserver& aObserver) + : iCommNotification(iCommNotificationDes()), + iObserver(aObserver), + iUnit(aUnit) +/** + * Constructor. + * + * @param aObserver The observer of the port, to be notified when the port + * closes. + * @param aUnit The port number. + */ + { + } + +void CAcmPort::StartRead(const TAny* aClientBuffer, TInt aLength) +/** + * Downcall from C32. Queue a read. + * + * @param aClientBuffer pointer to the client's buffer + * @param aLength number of bytes to read + */ + { + LOG_LINE + LOG_FUNC + LOGTEXT3(_L8("\taClientBuffer=0x%08x, aLength=%d"), + aClientBuffer, aLength); + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + ReadCompleted(KErrAccessDenied); + return; + } + + // Analyse the request and call the relevant API on the data reader. NB We + // do not pass requests for zero bytes to the data reader. They are an + // RComm oddity we should handle here. + __ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + if(iReader->IsNotifyDataAvailableQueryPending()) + { + ReadCompleted(KErrInUse); + return; + } + + if ( aLength < 0 ) + { + iReader->ReadOneOrMore(aClientBuffer, static_cast(-aLength)); + } + else if ( aLength > 0 ) + { + iReader->Read(aClientBuffer, static_cast(aLength)); + } + else + { + // Obscure RComm API feature- complete zero-length Read immediately, + // to indicate that the hardware is powered up. + LOGTEXT(_L8("\tcompleting immediately with KErrNone")); + ReadCompleted(KErrNone); + } + } + +void CAcmPort::ReadCancel() +/** + * Downcall from C32. Cancel a read. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return; + } + + __ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iReader->ReadCancel(); + } + +TInt CAcmPort::QueryReceiveBuffer(TInt& aLength) const +/** + * Downcall from C32. Get the amount of data in the receive buffer. + * + * @param aLength reference to where the amount will be written to + * @return Error. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return KErrAccessDenied; + } + + __ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + aLength = static_cast(iReader->BufLen()); + LOGTEXT2(_L8("\tlength=%d"), aLength); + return KErrNone; + } + +void CAcmPort::ResetBuffers(TUint aFlags) +/** + * Downcall from C32. Reset zero or more of the Tx and Rx buffers. + * + * @param aFlags Flags indicating which buffer(s) to reset. + */ + { + LOG_LINE + LOGTEXT2(_L8(">>CAcmPort::ResetBuffers aFlags = %d"), aFlags); + + if ( aFlags & KCommResetRx ) + { + LOGTEXT(_L8("\tresetting Rx buffer")); + __ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iReader->ResetBuffer(); + } + + if ( aFlags & KCommResetTx ) + { + LOGTEXT(_L8("\tresetting Tx buffer")); + __ASSERT_DEBUG(iWriter, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iWriter->ResetBuffer(); + } + + LOGTEXT(_L8("<Write(aClientBuffer, static_cast(aLength)); + } + +void CAcmPort::WriteCancel() +/** + * Downcall from C32. Cancel a pending write + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return; + } + + __ASSERT_DEBUG(iWriter, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iWriter->WriteCancel(); + } + +void CAcmPort::Break(TInt aTime) +/** + * Downcall from C32. Send a break signal to the host. + * Note that it is assumed that the NotifyBreak() request only applies to + * break signals sent from the host. + * + * @param aTime Length of break in microseconds + */ + { + LOG_LINE + LOG_FUNC + LOGTEXT2(_L8("\taTime=%d (microseconds)"), aTime); + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return; + } + + iBreak = ETrue; + iCancellingBreak = EFalse; + + // Use the time value directly as microseconds are given. We are a USB + // 'device' so the RComm client is always on the device side. + TInt err = iAcm->BreakRequest(CBreakController::EDevice, + CBreakController::ETiming, + TTimeIntervalMicroSeconds32(aTime)); + LOGTEXT2(_L8("\tBreakRequest = %d"), err); + // Note that the break controller may refuse our request if a host-driven + // break is outstanding. + if ( err ) + { + LOGTEXT2(_L8("\tcalling BreakCompleted with %d"), err); + iBreak = EFalse; + BreakCompleted(err); + } + } + +void CAcmPort::BreakCancel() +/** + * Downcall from C32. Cancel a pending break. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return; + } + + iCancellingBreak = ETrue; + + TInt err = iAcm->BreakRequest(CBreakController::EDevice, + CBreakController::EInactive); + // Note that the device cannot turn off a break if there's a host-driven + // break in progress. + LOGTEXT2(_L8("\tBreakRequest = %d"), err); + if ( err ) + { + iCancellingBreak = EFalse; + } + + // Whether BreakOff worked or not, reset our flag saying we're no longer + // interested in any subsequent completion anyway. + iBreak = EFalse; + } + +TInt CAcmPort::GetConfig(TDes8& aDes) const +/** + * Downcall from C32. Pass a config request. Only supports V01. + * + * @param aDes config will be written to this descriptor + * @return Error. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return KErrAccessDenied; + } + + if ( aDes.Length() < static_cast(sizeof(TCommConfigV01)) ) + { + LOGTEXT(_L8("\t***not supported")); + return KErrNotSupported; + } + + TCommConfig commConfigPckg; + TCommConfigV01& commConfig = commConfigPckg(); + commConfig = iCommConfig; + + aDes.Copy(commConfigPckg); + + LOGTEXT2(_L8("\tiCommConfig.iRate = %d"), iCommConfig.iRate); + LOGTEXT2(_L8("\tiCommConfig.iDataBits = %d"), iCommConfig.iDataBits); + LOGTEXT2(_L8("\tiCommConfig.iStopBits = %d"), iCommConfig.iStopBits); + LOGTEXT2(_L8("\tiCommConfig.iParity = %d"), iCommConfig.iParity); + LOGTEXT2(_L8("\tiCommConfig.iHandshake = %d"), iCommConfig.iHandshake); + LOGTEXT2(_L8("\tiCommConfig.iParityError = %d"), + iCommConfig.iParityError); + LOGTEXT2(_L8("\tiCommConfig.iFifo = %d"), iCommConfig.iFifo); + LOGTEXT2(_L8("\tiCommConfig.iSpecialRate = %d"), + iCommConfig.iSpecialRate); + LOGTEXT2(_L8("\tiCommConfig.iTerminatorCount = %d"), + iCommConfig.iTerminatorCount); + LOGTEXT2(_L8("\tiCommConfig.iSIREnable = %d"), iCommConfig.iSIREnable); + LOGTEXT2(_L8("\tiCommConfig.iSIRSettings = %d"), + iCommConfig.iSIRSettings); + + return KErrNone; + } + +TInt CAcmPort::SetConfig(const TDesC8& aDes) +/** + * Downcall from C32. Set config on the port using a TCommConfigV01 package. + * + * @param aDes descriptor containing the new config + * @return Error + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return KErrAccessDenied; + } + + LOGTEXT4(_L8("\tlength of argument %d, TCommConfigV01 %d, " + "TCommConfigV02 %d"), + aDes.Length(), + (TInt)sizeof(TCommConfigV01), + (TInt)sizeof(TCommConfigV02)); + + if ( aDes.Length() < static_cast(sizeof(TCommConfigV01)) ) + { + LOGTEXT(_L8("\t***not supported")); + return KErrNotSupported; + } + + TCommConfig configPckg; + configPckg.Copy(aDes); + TCommConfigV01& config = configPckg(); + + LOGTEXT2(_L8("\tiCommConfig.iRate = %d"), config.iRate); + LOGTEXT2(_L8("\tiCommConfig.iDataBits = %d"), config.iDataBits); + LOGTEXT2(_L8("\tiCommConfig.iStopBits = %d"), config.iStopBits); + LOGTEXT2(_L8("\tiCommConfig.iParity = %d"), config.iParity); + LOGTEXT2(_L8("\tiCommConfig.iHandshake = %d"), config.iHandshake); + LOGTEXT2(_L8("\tiCommConfig.iParityError = %d"), config.iParityError); + LOGTEXT2(_L8("\tiCommConfig.iFifo = %d"), config.iFifo); + LOGTEXT2(_L8("\tiCommConfig.iSpecialRate = %d"), config.iSpecialRate); + LOGTEXT2(_L8("\tiCommConfig.iTerminatorCount = %d"), + config.iTerminatorCount); + LOGTEXT2(_L8("\tiCommConfig.iSIREnable = %d"), config.iSIREnable); + LOGTEXT2(_L8("\tiCommConfig.iSIRSettings = %d"), config.iSIRSettings); + + // Tell the reader object about the new terminators. Pass the whole config + // struct by reference for ease. + iReader->SetTerminators(config); + + HandleConfigNotification(config.iRate, + config.iDataBits, + config.iParity, + config.iStopBits, + config.iHandshake); + iCommConfig = config; + + return KErrNone; + } + +void CAcmPort::HandleConfigNotification(TBps aRate, + TDataBits aDataBits, + TParity aParity, + TStopBits aStopBits, + TUint aHandshake) +/** + * Construct and complete the config notification data structure. + * @param aRate New data rate + * @param aDataBits New number of data bits + * @param aParity New parity check setting + * @param aStopBits New stop bit setting + * @param aHandshake New handshake setting + */ + { + LOGTEXT(_L8(">>CAcmPort::HandleConfigNotification")); + LOGTEXT2(_L8("\taRate = %d"), aRate); + LOGTEXT2(_L8("\taDataBits = %d"), aDataBits); + LOGTEXT2(_L8("\taStopBits = %d"), aStopBits); + LOGTEXT2(_L8("\taParity = %d"), aParity); + LOGTEXT2(_L8("\taHandshake = %d"), aHandshake); + + iCommNotification.iChangedMembers = 0; + + iCommNotification.iRate = aRate; + if ( iCommConfig.iRate != aRate ) + { + iCommNotification.iChangedMembers |= KRateChanged; + } + + iCommNotification.iDataBits = aDataBits; + if ( iCommConfig.iDataBits != aDataBits ) + { + iCommNotification.iChangedMembers |= KDataFormatChanged; + } + + iCommNotification.iParity = aParity; + if ( iCommConfig.iParity != aParity ) + { + iCommNotification.iChangedMembers |= KDataFormatChanged; + } + + iCommNotification.iStopBits = aStopBits; + if ( iCommConfig.iStopBits != aStopBits ) + { + iCommNotification.iChangedMembers |= KDataFormatChanged; + } + + iCommNotification.iHandshake = aHandshake; + if ( iCommConfig.iHandshake != aHandshake ) + { + iCommNotification.iChangedMembers |= KHandshakeChanged; + } + + if ( iCommNotification.iChangedMembers ) + { + LOGTEXT(_L8("\tcalling ConfigChangeCompleted with KErrNone")); + ConfigChangeCompleted(iCommNotificationDes,KErrNone); + iNotifyConfigChange = EFalse; + } + + LOGTEXT(_L8("<(sizeof(TCommServerConfigV01)) ) + { + LOGTEXT(_L8("\t***not supported")); + return KErrNotSupported; + } + + TCommServerConfig serverConfigPckg; + serverConfigPckg.Copy(aDes); + TCommServerConfigV01& serverConfig = serverConfigPckg(); + + if ( serverConfig.iBufFlags != KCommBufferFull ) + { + LOGTEXT(_L8("\t***not supported")); + return KErrNotSupported; + } + + // Apply the buffer size setting to Rx and Tx buffers. + TInt err = DoSetBufferLengths(serverConfig.iBufSize); + if ( err ) + { + // Failure- the buffer lengths will have been left as they were, so + // just return error. + LOGTEXT2(_L8("\t***DoSetBufferLengths=%d"), err); + return err; + } + + // Changed buffer sizes OK. Note that new config. + iCommServerConfig = serverConfig; + return KErrNone; + } + +TInt CAcmPort::GetServerConfig(TDes8& aDes) +/** + * Downcall from C32. Get the server configs. Only supports V01. + * + * @param aDes server configs will be written to this descriptor + * @return Error. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return KErrAccessDenied; + } + + if ( aDes.Length() < static_cast(sizeof(TCommServerConfigV01)) ) + { + LOGTEXT(_L8("\t***not supported")); + return KErrNotSupported; + } + + TCommServerConfig* serverConfigPckg = + reinterpret_cast(&aDes); + TCommServerConfigV01& serverConfig = (*serverConfigPckg)(); + + serverConfig = iCommServerConfig; + return KErrNone; + } + +TInt CAcmPort::GetCaps(TDes8& aDes) +/** + * Downcall from C32. Get the port's capabilities. Supports V01 and V02. + * + * @param aDes caps will be written to this descriptor + * @return Error. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return KErrAccessDenied; + } + + TCommCaps2 capsPckg; + TCommCapsV02& caps = capsPckg(); + + switch ( aDes.Length() ) + { + case sizeof(TCommCapsV02): + { + caps.iNotificationCaps = (KCapsNotification | KNotifyDataAvailableSupported); + caps.iRoleCaps = KCapsRoles; + caps.iFlowControlCaps = KCapsFlowControl; + } + // no break is deliberate + case sizeof(TCommCapsV01): + { + caps.iRate = KCapsRate; + caps.iDataBits = KCapsDataBits; + caps.iStopBits = KCapsStopBits; + caps.iParity = KCapsParity; + caps.iHandshake = KCapsHandshaking; + caps.iSignals = KCapsSignals; + caps.iFifo = KCapsFifo; + caps.iSIR = KCapsSIR; + } + break; + default: + { + LOGTEXT(_L8("\t***bad argument")); + return KErrArgument; + } + } + + aDes.Copy(capsPckg.Left(aDes.Length())); + + return KErrNone; + } + +TInt CAcmPort::GetSignals(TUint& aSignals) +/** + * Downcall from C32. Get the status of the signal pins + * + * @param aSignals signals will be written to this descriptor + * @return Error. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return KErrAccessDenied; + } + + aSignals = ConvertSignals(iSignals); + + LOGTEXT3(_L8("iSignals=0x%x, aSignals=0x%x"), + iSignals, aSignals); + return KErrNone; + } + +TInt CAcmPort::SetSignalsToMark(TUint aSignals) +/** + * Downcall from C32. Set selected signals to high (logical 1) + * + * @param aSignals bitmask with the signals to be set + * @return Error. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return KErrAccessDenied; + } + + TUint32 newSignals = iSignals | ConvertAndFilterSignals(aSignals); + TInt err = SetSignals(newSignals); + if ( err ) + { + LOGTEXT2(_L8("***SetSignals = %d"), err); + return err; + } + + LOGTEXT3(_L8("iSignals=0x%x, aSignals=0x%x"), + iSignals, aSignals); + return KErrNone; + } + +TInt CAcmPort::SetSignalsToSpace(TUint aSignals) +/** + * Downcall from C32. Set selected signals to low (logical 0) + * + * @param aSignals bitmask with the signals to be cleared + * @return Error. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return KErrAccessDenied; + } + + TUint32 newSignals = iSignals & ~ConvertAndFilterSignals(aSignals); + TInt err = SetSignals(newSignals); + if ( err ) + { + LOGTEXT2(_L8("***SetSignals = %d"), err); + return err; + } + + LOGTEXT3(_L8("iSignals=0x%x, aSignals=0x%x"), + iSignals, aSignals); + return KErrNone; + } + +TInt CAcmPort::SetSignals(TUint32 aNewSignals) +/** + * Handle a request by the client to change signal state. This function pushes + * the change to the host, completes any outstanding notifications, and stores + * the new signals in iSignals if there are no errors. + * + * @param aSignals bitmask with the signals to be set + * @return Error. + */ + { + LOG_FUNC + + TBool ring =((aNewSignals & KSignalRNG)==KSignalRNG); + TBool dsr =((aNewSignals & KSignalDSR)==KSignalDSR); + TBool dcd =((aNewSignals & KSignalDCD)==KSignalDCD); + + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return KErrAccessDenied; + } + + TInt err = iAcm->SendSerialState(ring,dsr,dcd); + if ( err ) + { + LOGTEXT2(_L8("\t***SendSerialState = %d- returning"), err); + return err; + } + + // Report the new signals if they have changed and notification mask shows + // the upper layer wanted to be sensitive to these signals + if ( iNotifySignalChange ) + { + TUint32 changedSignals = ( iSignals ^ aNewSignals ) & iNotifySignalMask; + if ( changedSignals != 0 ) + { + // Mark which signals have changed + // Could do something like: + // changedSignalsMask = ( changedSignals & (KSignalRNG|KSignalDCD|KSignalDSR) ) * KSignalChanged + // but this relies on the how the signal constants are formed in d32comm.h + TUint32 changedSignalsMask = 0; + if ( ( changedSignals & KSignalRNG ) != 0 ) + { + changedSignalsMask |= KRNGChanged; + } + if ( ( changedSignals & KSignalDCD ) != 0 ) + { + changedSignalsMask |= KDCDChanged; + } + if ( ( changedSignals & KSignalDSR ) != 0 ) + { + changedSignalsMask |= KDSRChanged; + } + + // Report correctly mapped signals that client asked for + LOGTEXT(_L8("\tcalling SignalChangeCompleted with KErrNone")); + TUint32 signals = ConvertSignals ( changedSignalsMask | ( aNewSignals & iNotifySignalMask ) ); + SignalChangeCompleted ( signals, KErrNone ); + iNotifySignalChange = EFalse; + } + } + + // Store new signals in iSignals + iSignals = aNewSignals; + + return KErrNone; + } + +TUint32 CAcmPort::ConvertAndFilterSignals(TUint32 aSignals) const +/** + * This function maps from signals used for the port's current role + * to the DCE signals used internally, filtering out signals that are + * inputs for the current role. + * + * This would be used, for example, to parse the signals specified by the + * client for a "SetSignals" request before storage in the iSignals member + * variable (always DCE). + * + * @param aSignals Input signals. + * @return The signals, with the lines switched round according to the port's + * role. + */ + { + LOG_FUNC + + TUint32 signals = 0; + + // note that this never allows the client to use this method + // to diddle the BREAK state + + // handle role-specific mapping + if ( iRole == ECommRoleDTE ) + { + // Ignore DSR, DCD, RI and CTS as these are DTE inputs. + + // Map DTR to DSR + if((aSignals&KSignalDTR)==KSignalDTR) + { + signals|=KSignalDSR; + } + + // Map RTS to CTS + if((aSignals&KSignalRTS)==KSignalRTS) + { + signals|=KSignalCTS; + } + } + else // iRole==EDce + { + // Ignore RTS and DTR as these are DCE inputs and therefore cannot be set. + // Keep mapping of DSR, CTS, DCD and RI. + signals |= aSignals & + ( KSignalDSR + | KSignalCTS + | KSignalDCD + | KSignalRNG); + } + + return signals; + } + +TUint32 CAcmPort::ConvertSignals(TUint32 aSignals) const +/** + * This function converts the given signals between the internal mapping + * and the client mapping, taking into account the port's currnt role. + * As the mapping is one to one, the input can be either the client or + * internal signals. + * + * This would be used, for example, to parse the signals being sent to the + * client in a "GetSignals" request, or to parse the signals sent from the + * client when setting up a notification. + * + * It should not be used for "SetSignals", as it does not take into account + * what signals are inputs or outputs for the current role. + * + * @param aSignals Input signals (internal or client). + * @return Output signals. + * port is. + */ + { + LOG_FUNC + + // Swap signals around if the client is expecting DTE signalling + if ( iRole == ECommRoleDTE ) + { + TUint32 swappedSignals = 0; + + // Map DSR to DTR + if ( ( aSignals & KSignalDSR ) == KSignalDSR ) + { + swappedSignals |= KSignalDTR; + } + if ( ( aSignals & KSignalDTR ) == KSignalDTR ) + { + swappedSignals |= KSignalDSR; + } + if ( ( aSignals & KDSRChanged ) != 0 ) + { + swappedSignals |= KDTRChanged; + } + if ( ( aSignals & KDTRChanged ) != 0 ) + { + swappedSignals |= KDSRChanged; + } + + // Map CTS to RTS + if ( ( aSignals&KSignalCTS ) == KSignalCTS ) + { + swappedSignals|=KSignalRTS; + } + if ( ( aSignals&KSignalRTS ) == KSignalRTS ) + { + swappedSignals|=KSignalCTS; + } + if ( ( aSignals & KCTSChanged ) != 0 ) + { + swappedSignals |= KRTSChanged; + } + if ( ( aSignals & KRTSChanged ) != 0 ) + { + swappedSignals |= KCTSChanged; + } + + // Put remapped signals back in + const TUint32 KSwapSignals = KSignalDSR | KSignalDTR | KSignalCTS | KSignalRTS + | KDSRChanged | KDTRChanged | KCTSChanged | KRTSChanged; + aSignals = ( aSignals & ~KSwapSignals ) | swappedSignals; + } + + return aSignals; + } + +TInt CAcmPort::GetReceiveBufferLength(TInt& aLength) const +/** + * Downcall from C32. Get size of Rx buffer. Note that the Rx and Tx + * buffers are assumed by the RComm API to always have the same size. + * We don't check here, but the value returned should be the size of the Tx + * buffer also. + * + * @param aLength reference to where the length will be written to + * @return Error. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return KErrAccessDenied; + } + + __ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + aLength = static_cast(iReader->BufSize()); + LOGTEXT2(_L8("\tlength=%d"), aLength); + return KErrNone; + } + +TInt CAcmPort::DoSetBufferLengths(TUint aLength) +/** + * Utility to set the sizes of the Rx and Tx buffers. On failure, the buffers + * will be left at the size they were. + * + * @param aLength The size required. + * @return Error. + */ + { + LOG_FUNC + LOGTEXT2(_L8("\taLength=%d"), aLength); + + __ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + // Sart trying to resize buffers. Start with the reader. + // Before we start though, set some stuff up we may need later (see + // comments below). + const TUint oldSize = iReader->BufSize(); + HBufC* dummyBuffer = HBufC::New(static_cast(oldSize)); + if ( !dummyBuffer ) + { + // If we can't allocate the dummy buffer, we can't guarantee that we + // can roll back this API safely if it fails halfway through. So abort + // the entire operation. + LOGTEXT(_L8("\t***failed to allocate dummy buffer- " + "returning KErrNoMemory")); + return KErrNoMemory; + } + + TInt ret = iReader->SetBufSize(aLength); + if ( ret ) + { + // A failure in SetBufSize will have maintained the old buffer + // (i.e. at its old size). This is a safe failure case- simply + // clean up and return the error to the client. + delete dummyBuffer; + LOGTEXT2(_L8("\t***SetBufSize on reader failed with %d"), ret); + return ret; + } + + // OK, the Rx buffer has been resized, now for the Tx buffer... + __ASSERT_DEBUG(iWriter, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + ret = iWriter->SetBufSize(aLength); + if ( ret ) + { + // Failure! The Tx buffer is still safe, at its old size. However, + // to maintain the integrity of the API we need to reset the Rx + // buffer back to the old size. To make sure that this will work, free + // the dummy buffer we initially allocated. + delete dummyBuffer; + LOGTEXT2(_L8("\t***SetBufSize on writer failed with %d"), ret); + TInt err = iReader->SetBufSize(oldSize); + __ASSERT_DEBUG(!err, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + static_cast(err); + // Now both buffers are at the size they started at, and the + // request failed with error code 'ret'. + return ret; + } + + // We seem to have successfully resized both buffers... clean up and + // return. + delete dummyBuffer; + + LOGTEXT(_L8("\treturning KErrNone")); + return KErrNone; + } + +TInt CAcmPort::SetReceiveBufferLength(TInt aLength) +/** + * Downcall from C32. Set the size of Rx buffer. Note that the Rx and Tx + * buffers are assumed by the RComm API to always have the same size. + * Therefore set the size of the Tx buffer also. + * + * @param aLength new length of Tx and Rx buffer + * @return Error. + */ + { + LOG_LINE + LOG_FUNC + LOGTEXT2(_L8("\taLength=%d"), aLength); + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return KErrAccessDenied; + } + + TInt ret = DoSetBufferLengths(static_cast(aLength)); + LOGTEXT2(_L8("\tDoSetBufferLengths=%d"), ret); + LOGTEXT2(_L8("\treturning %d"), ret); + return ret; + } + +void CAcmPort::Destruct() +/** + * Downcall from C32. Destruct - we must (eventually) call delete this + */ + { + LOG_FUNC + + delete this; + } + +void CAcmPort::FreeMemory() +/** + * Downcall from C32. Attempt to reduce our memory foot print. + * Implemented to do nothing. + */ + { + LOG_LINE + LOG_FUNC + } + +void CAcmPort::NotifyDataAvailable() +/** + * Downcall from C32. Notify client when data is available. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + NotifyDataAvailableCompleted(KErrAccessDenied); + return; + } + __ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + iReader->NotifyDataAvailable(); + } + +void CAcmPort::NotifyDataAvailableCancel() +/** + * Downcall from C32. Cancel an outstanding data available notification. Note + * that C32 actually completes the client's request for us. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return; + } + __ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + iReader->NotifyDataAvailableCancel(); + } + +TInt CAcmPort::GetFlowControlStatus(TFlowControl& /*aFlowControl*/) +/** + * Downcall from C32. Get the flow control status. NB This is not supported. + * + * @param aFlowControl flow control status will be written to this descriptor + * @return Error. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return KErrAccessDenied; + } + + LOGTEXT(_L8("\t***not supported")); + return KErrNotSupported; + } + +void CAcmPort::NotifyOutputEmpty() +/** + * Downcall from C32. Notify the client when the output buffer is empty. Note + * that this is not supported. Write requests only complete when the data has + * been sent to the LDD (KConfigWriteBufferedComplete is not supported) so + * it's not very useful. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + NotifyOutputEmptyCompleted(KErrAccessDenied); + return; + } + + LOGTEXT(_L8("\t***not supported")); + NotifyOutputEmptyCompleted(KErrNotSupported); + } + +void CAcmPort::NotifyOutputEmptyCancel() +/** + * Downcall from C32. Cancel a pending request to be notified when the output + * buffer is empty. Note that C32 actually completes the client's request for + * us. + */ + { + LOG_LINE + LOG_FUNC + } + +void CAcmPort::NotifyBreak() +/** + * Downcall from C32. Notify a client of a host-driven break on the serial + * line. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + BreakNotifyCompleted(KErrAccessDenied); + return; + } + + // C32 protects us against this. + __ASSERT_DEBUG(!iNotifyBreak, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + iNotifyBreak = ETrue; + } + +void CAcmPort::NotifyBreakCancel() +/** + * Downcall from C32. Cancel a pending notification of a serial line break. + * Note that C32 actually completes the client's request for us. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return; + } + + iNotifyBreak = EFalse; + } + +void CAcmPort::BreakRequestCompleted() +/** + * Callback for completion of a break request. + * This is called when the break state next goes inactive after a break has + * been requested from the ACM port. + * This is implemented to complete the RComm client's Break request. + */ + { + LOG_FUNC + + if ( !iCancellingBreak ) + { + LOGTEXT(_L8("\tcalling BreakCompleted with KErrNone")); + BreakCompleted(KErrNone); + } + else + { + LOGTEXT(_L8("\tbreak is being cancelled- " + "letting C32 complete the request")); + } + // In the event of an RComm::BreakCancel, this function is called + // sychronously with CAcmPort::BreakCancel, and C32 will complete the + // original RComm::Break request with KErrCancel when that returns. So we + // only need to complete it if there isn't a cancel going on. + iBreak = EFalse; + iCancellingBreak = EFalse; + } + +void CAcmPort::BreakStateChange() +/** + * Callback for a change in the break state. + * This is called both when the break state changes because the RComm client + * wanted it to, and when the break state changes because the host asked us + * to. + * This is implemented to update our signal line flags, complete + * NotifySignalChange requests, and complete NotifyBreak requests. + */ + { + LOG_FUNC + + // TODO: what if no iAcm? + + // Take a copy of the current signal state for comparison later + TUint32 oldSignals = iSignals; + + // grab the state of the BREAK from the ACM class that manages + // it and apply the appropriate flag state to the local iSignals + if ( iAcm && iAcm->BreakActive() ) + { + LOGTEXT(_L8("\tbreak is active")); + iSignals |= KSignalBreak; + } + else + { + LOGTEXT(_L8("\tbreak is inactive")); + iSignals &= ~KSignalBreak; + } + + // first tell the client (if interested, and if it's not a client-driven + // break) that there has been a BREAK event of some sort (either into or + // out of the break-active condition... + if ( iNotifyBreak && !iBreak ) + { + LOGTEXT(_L8("\tcalling BreakNotifyCompleted with KErrNone")); + BreakNotifyCompleted(KErrNone); + iNotifyBreak = EFalse; + } + + // and now tell the client (again if interested) the new state + // of the BREAK signal, if it has changed + if ( iNotifySignalChange + && ( ( iNotifySignalMask & ( iSignals ^ oldSignals ) ) != 0 ) ) + { + // Report correctly mapped signals that client asked for + LOGTEXT(_L8("\tcalling SignalChangeCompleted with KErrNone")); + TUint32 signals = ConvertSignals ( KBreakChanged | ( iSignals & iNotifySignalMask ) ); + SignalChangeCompleted( signals, KErrNone); + iNotifySignalChange = EFalse; + } + } + +void CAcmPort::NotifyFlowControlChange() +/** + * Downcall from C32. Notify a client of a change in the flow control state. + * Note that this is not supported. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + FlowControlChangeCompleted(EFlowControlOn, KErrAccessDenied); + return; + } + + LOGTEXT(_L8("\t***not supported")); + FlowControlChangeCompleted(EFlowControlOn,KErrNotSupported); + } + +void CAcmPort::NotifyFlowControlChangeCancel() +/** + * Downcall from C32. Cancel a pending request to be notified when the flow + * control state changes. Note that C32 actually completes the client's + * request for us. + */ + { + LOG_LINE + LOG_FUNC + } + +void CAcmPort::NotifyConfigChange() +/** + * Downcall from C32. Notify a client of a change to the serial port + * configuration. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + ConfigChangeCompleted(iCommNotificationDes, KErrAccessDenied); + return; + } + + if ( iNotifyConfigChange ) + { + LOGTEXT(_L8("\t***in use")); + ConfigChangeCompleted(iCommNotificationDes,KErrInUse); + } + else + { + iNotifyConfigChange = ETrue; + } + } + +void CAcmPort::NotifyConfigChangeCancel() +/** + * Downcall from C32. Cancel a pending request to be notified of a change to + * the serial port configuration. Note that C32 actually completes the + * client's request for us. + */ + { + LOG_LINE + LOG_FUNC + + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + return; + } + + iNotifyConfigChange = EFalse; + } + +void CAcmPort::HostConfigChange(const TCommConfigV01& aConfig) +/** + * Callback from a "host-pushed" configuration change packet. + * + * @param aConfig New configuration data. + */ + { + LOG_FUNC + + HandleConfigNotification(aConfig.iRate, + aConfig.iDataBits, + aConfig.iParity, + aConfig.iStopBits, + iCommConfig.iHandshake); + iCommConfig.iRate = aConfig.iRate; + iCommConfig.iDataBits = aConfig.iDataBits; + iCommConfig.iParity = aConfig.iParity; + iCommConfig.iStopBits = aConfig.iStopBits; + } + +void CAcmPort::NotifySignalChange(TUint aSignalMask) +/** + * Downcall from C32. Notify a client of a change to the signal lines. + */ + { + LOG_LINE + LOGTEXT2(_L8(">>CAcmPort::NotifySignalChange aSignalMask=0x%08x"), + aSignalMask); + + if ( iNotifySignalChange ) + { + if ( !iAcm ) + { + LOGTEXT(_L8("\t***access denied")); + SignalChangeCompleted(0, KErrAccessDenied); + } + else + { + LOGTEXT(_L8("\t***in use")); + SignalChangeCompleted(0, KErrInUse); + } + } + else + { + iNotifySignalChange = ETrue; + // convert signals to internal format + // no need to filter as can notify on inputs or outputs + iNotifySignalMask = ConvertSignals(aSignalMask); + } + + LOGTEXT(_L8("<>CAcmPort::HostSignalChange aDtr=%d, aRts=%d"), aDtr, aRts); + + // Take a copy of the current signal state for comparison later + TUint32 oldSignals = iSignals; + + if ( aDtr ) + { + iSignals |= KSignalDTR; + } + else + { + iSignals &= (~KSignalDTR); + } + + if ( aRts ) + { + iSignals |= KSignalRTS; + } + else + { + iSignals &= (~KSignalRTS); + } + + // Report the new state of the signals if they have changed + // and the mask shows the upper layer wanted to be sensitive to these signals. + if ( iNotifySignalChange ) + { + // Create bitfield of changed signals that client is interested in + TUint32 changedSignals = ( iSignals ^ oldSignals ) & iNotifySignalMask; + LOGTEXT5(_L8("\tiSignals=%x, oldSignals=%x, changedSignals=%x, iNotifySignalMask=%x") + ,iSignals, oldSignals, changedSignals, iNotifySignalMask); + if ( changedSignals != 0 ) + { + // Mark which signals have changed + TUint32 changedSignalsMask = 0; + if ( ( changedSignals & KSignalDTR ) != 0 ) + { + changedSignalsMask |= KDTRChanged; + } + if ( ( changedSignals & KSignalRTS ) != 0 ) + { + changedSignalsMask |= KRTSChanged; + } + LOGTEXT2(_L8("\tchangedSignalsMask=%x"), changedSignalsMask); + + // Report correctly mapped signals that client asked for + TUint32 signals = ConvertSignals ( changedSignalsMask | ( iSignals & iNotifySignalMask ) ); + LOGTEXT2(_L8("\tcalling SignalChangeCompleted with KErrNone, signals=%x"), signals); + SignalChangeCompleted( signals, KErrNone); + iNotifySignalChange = EFalse; + } + } + + LOGTEXT(_L8("<>CAcmPort::SetRole aRole=%d"), aRole); + + TInt ret = KErrNone; + if ( !iAcm ) + { + ret = KErrAccessDenied; + } + else + { + iRole = aRole; + } + + LOGTEXT2(_L8("<>CAcmPort::SetAcm aAcm = 0x%08x, iAcm = 0x%08x"), aAcm, iAcm); + + if ( !aAcm ) + { + // Cancel any outstanding operations on the reader and writer. + __ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iReader->ReadCancel(); + __ASSERT_DEBUG(iWriter, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iWriter->WriteCancel(); + + // Complete any outstanding requests + LOGTEXT(_L8("\tcompleting outstanding requests with KErrAccessDenied")); + SignalChangeCompleted(iSignals,KErrAccessDenied); + ReadCompleted(KErrAccessDenied); + WriteCompleted(KErrAccessDenied); + ConfigChangeCompleted(iCommNotificationDes,KErrAccessDenied); + NotifyDataAvailableCompleted(KErrAccessDenied); + NotifyOutputEmptyCompleted(KErrAccessDenied); + BreakNotifyCompleted(KErrAccessDenied); + FlowControlChangeCompleted(EFlowControlOn, KErrAccessDenied); + } + else + { + __ASSERT_DEBUG(!iAcm, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + aAcm->SetCallback(this); + // Set the port as the observer of break events. + aAcm->SetBreakCallback(this); + } + + iAcm = aAcm; + + LOGTEXT(_L8("<SetCallback(NULL); + } + + LOGTEXT(_L8("\tcalling AcmPortClosed on observer")); + iObserver.AcmPortClosed(iUnit); + } + +// +// End of file diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/AcmPortFactory.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/AcmPortFactory.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,429 @@ +/* +* 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: +* +*/ + +#include "AcmPortFactory.h" +#include "AcmUtils.h" +#include +#include "AcmPort.h" +#include "AcmPanic.h" +#include "acmserver.h" +#include "CdcAcmClass.h" +#include +#include "c32comm_internal.h" + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +// Do not move this into a header file. It must be kept private to the CSY. It +// is the secret information that enables the old (registration port) +// mechanism allowing the USB Manager to set up ACM interfaces. +const TUint KRegistrationPortUnit = 666; + +CAcmPortFactory* CAcmPortFactory::NewL() +/** + * Make a new CAcmPortFactory + * + * @return Ownership of a newly created CAcmPortFactory object + */ + { + LOG_STATIC_FUNC_ENTRY + + CAcmPortFactory* self = new(ELeave) CAcmPortFactory; + CleanupClosePushL(*self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +CAcmPortFactory::CAcmPortFactory() +/** + * Constructor. + */ + { + iVersion = TVersion( + KEC32MajorVersionNumber, + KEC32MinorVersionNumber, + KEC32BuildVersionNumber); + iConfigBuf().iAcmConfigVersion = 1; + iOwned = EFalse; + } + +void CAcmPortFactory::ConstructL() +/** + * Second phase constructor. + */ + { + LEAVEIFERRORL(SetName(&KAcmSerialName)); + iAcmServer = CAcmServer::NewL(*this); + + TInt err = RProperty::Define(KUidSystemCategory, KAcmKey, RProperty::EByteArray, TPublishedAcmConfigs::KAcmMaxFunctions); + if(err == KErrAlreadyExists) + { + LEAVEIFERRORL(iAcmProperty.Attach(KUidSystemCategory, KAcmKey, EOwnerThread)); + //Since the P&S data already exists we need to retrieve it + LEAVEIFERRORL(iAcmProperty.Get(iConfigBuf)); + } + else if(err == KErrNone) + { + //A blank iConfigBuf already exists at this point to we don't need to do anything to it + //before publishing the P&S data + LEAVEIFERRORL(iAcmProperty.Attach(KUidSystemCategory, KAcmKey, EOwnerThread)); + PublishAcmConfig(); + iOwned = ETrue; + } + else + { + LEAVEIFERRORL(err); //This will always leave, but a log will be created at least. + } + + } + +/** + * Utility function for publishing the TPublishedAcmConfigs data + * @pre Requires iAcmProperty to be attached before it is called + */ +void CAcmPortFactory::PublishAcmConfig() + { + // Update the publish and subscribe info + TInt err = iAcmProperty.Set(iConfigBuf); + __ASSERT_DEBUG(err == KErrNone, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + (void)err; + } + +TSecurityPolicy CAcmPortFactory::PortPlatSecCapability (TUint aPort) const +/** + * Called by C32 when it needs to check the capabilities of a client against the + * capabilites required to perform C32 defered operations on this port, aPort. + * + * @param aPort The number of the port. + * @return a security policy + */ + //return the security policy for the given port number, aPort. + { + LOG_FUNC + + TSecurityPolicy securityPolicy; + if ( aPort == KRegistrationPortUnit ) + { + securityPolicy = TSecurityPolicy(ECapabilityNetworkControl); + } + else + { + securityPolicy = TSecurityPolicy(ECapabilityLocalServices); + } + return securityPolicy; + } + +void CAcmPortFactory::AcmPortClosed(const TUint aUnit) +/** + * Called by an ACM port when it is closed. + * + * @param aUnit The port number of the closing port. + */ + { + LOG_FUNC + LOGTEXT2(_L8("\taUnit = %d"), aUnit); + + // I would assert that the calling port is stored in our array, but if we + // ran out of memory during CAcmPort::NewL, this function would be called + // from the port's destructor, but the slot in the port array would still + // be NULL. + + // Reset the slot in our array of ports. + const TUint index = aUnit - KAcmLowUnit; + iAcmPortArray[index] = NULL; + +#ifdef _DEBUG + LogPortsAndFunctions(); +#endif + } + +CAcmPortFactory::~CAcmPortFactory() +/** + * Destructor. + */ + { + LOG_FUNC + + // Delete ACM instances. We could assert that the ACM Class Controller has + // caused them all to be destroyed, but if we do that, and USBSVR panics + // while it's Started, it will result in C32 panicking too, which is + // undesirable. TODO: I'm not sure about this philosophy. + iAcmClassArray.ResetAndDestroy(); + + // We don't need to clean this array up because C32 will not shut us down + // while ports are still open on us. + iAcmPortArray.Close(); + + // Detach the local handles + iAcmProperty.Close(); + + // Remove the RProperty entries if they are owned by this instance of the PortFactory + if(iOwned) + { + RProperty::Delete(KUidSystemCategory, KAcmKey); + } + + delete iAcmServer; + } + +CPort* CAcmPortFactory::NewPortL(const TUint aUnit) +/** + * Downcall from C32. Create a new port for the supplied unit number. + * + * @param aUnit Port unit number + */ + { + LOG_LINE + LOGTEXT2(_L8(">>CAcmPortFactory::NewPortL aUnit=%d"), aUnit); + + CPort* port = NULL; + + TUint lowerLimit = KAcmLowUnit; // This non-const TUint avoids compiler remarks (low-level warnings) for the following comparisons.. + // ACM ports + if ( (aUnit >= lowerLimit) && aUnit < static_cast( iAcmClassArray.Count()) + KAcmLowUnit) + { + // Can only create an ACM port if the corresponding ACM interface + // itself has been created. We keep the slots in the iAcmClassArray array + // up-to-date with how many ACM interface instances have been created. + const TUint index = aUnit - KAcmLowUnit; + if ( iAcmPortArray[index] ) + { + LEAVEIFERRORL(KErrInUse); // TODO: is this ever executed? + } + iAcmPortArray[index] = CAcmPort::NewL(aUnit, *this); + iAcmPortArray[index]->SetAcm( iAcmClassArray[index]); + port = iAcmPortArray[index]; + } + // Registration port + else if ( aUnit == KRegistrationPortUnit ) + { + port = CRegistrationPort::NewL(*this, KRegistrationPortUnit); + } + else + { + LEAVEIFERRORL(KErrAccessDenied); + } + +#ifdef _DEBUG + LogPortsAndFunctions(); +#endif + + LOGTEXT2(_L8("<>CAcmPortFactory::DestroyFunctions aNoAcms = %d"), aNoAcms); + +#ifdef _DEBUG + CheckAcmArray(); +#endif + + for ( TUint ii = 0 ; ii < aNoAcms ; ii++ ) + { + const TUint index = iAcmClassArray.Count() - 1; + + // Inform the relevant ACM ports, if any, so they can complete + // outstanding requests. NB The ACM port array should have been padded + // up adequately, but not necessarily filled with ports. + if ( iAcmPortArray[index] ) + { + iAcmPortArray[index]->SetAcm(NULL); + // Don't remove slots from the ACM port array, because higher- + // indexed ports might still be open. + } + + // Destroy ACM interface. + delete iAcmClassArray[index]; + iAcmClassArray.Remove(index); + } + + //decrement the published configurations counter + iConfigBuf().iAcmCount -= aNoAcms; + PublishAcmConfig(); + +#ifdef _DEBUG + CheckAcmArray(); + LogPortsAndFunctions(); +#endif + + LOGTEXT(_L8("<( iAcmClassArray.Count()) ; ii++ ) + { + __ASSERT_DEBUG( iAcmClassArray[ii], _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + } + } + +TInt CAcmPortFactory::CreateFunctions(const TUint aNoAcms, const TUint8 aProtocolNum, const TDesC16& aAcmControlIfcName, const TDesC16& aAcmDataIfcName) +/** + * Tries to create the ACM functions. + * + * @param aNoAcms Number of ACM functions to create. + * @param aProtocolNum Protocol setting to use for these ACM functions. + * @param aAcmControlIfcName Control Interface Name or a null descriptor + * @param aAcmDataIfcName Data Interface Name or a null descriptor + */ + { + LOGTEXT5(_L("\taNoAcms = %d, aProtocolNum = %d, Control Ifc Name = %S, Data Ifc Name = %S"), + aNoAcms, aProtocolNum, &aAcmControlIfcName, &aAcmDataIfcName); + +#ifdef _DEBUG + CheckAcmArray(); +#endif + + TInt ret = KErrNone; + + // Create the ACM class instances. + for ( TUint ii = 0 ; ii < aNoAcms ; ii++ ) + { + LOGTEXT2(_L8("\tabout to create ACM instance %d"), ii); + TRAP(ret, CreateFunctionL(aProtocolNum, aAcmControlIfcName, aAcmDataIfcName)); + if ( ret != KErrNone ) + { + // Destroy the most recent ACMs that _did_ get created. + DestroyFunctions(ii); + break; + } + } + + // all the ACM Functions should now have been created. publish the data + PublishAcmConfig(); + +#ifdef _DEBUG + CheckAcmArray(); + LogPortsAndFunctions(); +#endif + + LOGTEXT2(_L8("<SetAcm(acm); + } + + // update the TPublishedAcmConfig with the current details + iConfigBuf().iAcmConfig[iConfigBuf().iAcmCount].iProtocol = aProtocolNum; + iConfigBuf().iAcmCount++; + //don't update the p&s data here, do it in CreateFunctions after the construction of + //all the requested functions + } + +void CAcmPortFactory::Info(TSerialInfo& aSerialInfo) +/** + * Get info about this CSY, fill in the supplied structure. + * + * @param aSerialInfo where info will be written to + */ + { + // NB Our TSerialInfo does not advertise the existence of the registration + // port. + LOG_FUNC + + _LIT(KSerialDescription, "USB Serial Port Emulation via ACM"); + aSerialInfo.iDescription = KSerialDescription; + aSerialInfo.iName = KAcmSerialName; + aSerialInfo.iLowUnit = KAcmLowUnit; + aSerialInfo.iHighUnit = (iAcmPortArray.Count()==0) ? 0 : (iAcmPortArray.Count()-1); + // See comments in AcmInterface.h + } + +void CAcmPortFactory::LogPortsAndFunctions() +/** + * Utility to log in a tabular form all the ACM function instances and any + * associated ports. + * The number of ACM functions listed is the number we have been asked to + * make which we have made successfully. All the ACM + * functions listed should be pointing somewhere (enforced by CheckAcmArray). + * Any or all of the ACM ports may be NULL, indicating simply that the client + * side hasn't opened an RComm on that ACM port yet. + * It may also be the case that there are more ACM port slots than there are + * ACM functions slots. This just means that USB is in a more 'Stopped' state + * than it has been in the past- the ports in these slots may still be open, + * so the ACM port array must retain slots for them. + * All this is just so the logging gives a clear picture of the functions and + * port open/closed history of the CSY. + */ + { + TUint ii; + + // Log ACM functions and corresponding ports. + for ( ii = 0 ; ii < static_cast( iAcmClassArray.Count()) ; ii++ ) + { + LOGTEXT5(_L8("\t iAcmClassArray[%d] = 0x%08x, iAcmPortArray[%d] = 0x%08x"), ii, iAcmClassArray[ii], ii, iAcmPortArray[ii]); + } + // Log any ports extending beyond where we currently have ACM interfaces. + for ( ; ii < static_cast(iAcmPortArray.Count()) ; ii++ ) + { + LOGTEXT4(_L8("\t iAcmClassArray[%d] = , iAcmPortArray[%d] = 0x%08x"), ii, ii, iAcmPortArray[ii]); + } + } + +// +// End of file diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/AcmReader.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/AcmReader.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,870 @@ +/* +* 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 +#include "AcmReader.h" +#include "AcmUtils.h" +#include "ActiveReader.h" +#include "ActiveReadOneOrMoreReader.h" +#include "CdcAcmClass.h" +#include "AcmPanic.h" +#include "AcmPort.h" +#include + +#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("<Des(); + iBufStart = const_cast(reinterpret_cast(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(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(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::ReadOneOrMoreCompleted aError=%d"), aError); + + const TUint justRead = static_cast(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::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("< 0, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + __ASSERT_DEBUG(aMaxLen <= static_cast(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); + } + // Sanity check on what C32 gave us. + __ASSERT_DEBUG(aClientBuffer, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + // Make a note of interesting data. + iCurrentRequest.iClientPtr = aClientBuffer; + iLengthToGo = aMaxLen; + iOffsetIntoClientsMemory = 0; + } + +void CAcmReader::CheckForBufferedTerminatorsAndProceed() +/** + * Checks for terminator characters in the buffer. Completes the client's + * request if possible, and issues further ReadOneOrMores for the appropriate + * amount if not. + */ + { + LOG_FUNC + + TInt ret = FindTerminator(); + LOGTEXT2(_L8("\tFindTerminator = %d"), ret); + if ( ret < KErrNone ) + { + LOGTEXT(_L8("\tno terminator found")); + const TUint bufLen = BufLen(); + LOGTEXT2(_L8("\tbufLen = %d"), bufLen); + // No terminator was found. Does the buffer already exceed the + // client's descriptor? + if ( bufLen >= iLengthToGo ) + { + // Yes- complete as much data to the client as their + // descriptor can handle. + LOGTEXT2(_L8("\tbuffer >= client descriptor- " + "writing back %d bytes"), iLengthToGo); + WriteBackData(iLengthToGo); + CompleteRequest(KErrNone); + } + else + { + // No- write back the data we've got and issue a request to get + // some more data. + WriteBackData(bufLen); + IssueReadOneOrMore(); + } + } + else + { + LOGTEXT(_L8("\tterminator found!")); + // Will the terminator position fit within the client's descriptor? + if ( static_cast(ret) <= iLengthToGo ) + { + // Yes- complete (up to the terminator) back to the client. + LOGTEXT2(_L8("\tterminator will fit in client's descriptor- " + "writing back %d bytes"), ret); + WriteBackData(static_cast(ret)); + CompleteRequest(KErrNone); + } + else + { + // No- complete as much data to the client as their descriptor can + // handle. + LOGTEXT2(_L8("\tterminator won't fit in client's descriptor- " + "writing back %d bytes"), iLengthToGo); + WriteBackData(iLengthToGo); + CompleteRequest(KErrNone); + } + } + } + +void CAcmReader::WriteBackData(TUint aLength) +/** + * This function writes back data to the client address space. The write will + * be performed in one go if the data to be written back is not wrapped across + * the end of the circular buffer. If the data is wrapped, the write is done + * in two stages. The read pointer is updated to reflect the data consumed, as + * is the counter for remaining data required by the client (iLengthToGo), and + * the pointer into the client's memory (iOffsetIntoClientsMemory). + * + * @param aLength Amount of data to write back. + */ + { + LOGTEXT2(_L8("CAcmReader::WriteBackData aLength = %d"), aLength); + LOGTEXT2(_L8("\tBufLen() = %d"), BufLen()); + + LOGTEXT2(_L8("\tBufLen() = %d"), BufLen()); + + __ASSERT_DEBUG(aLength <= BufLen(), + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + const TUint lenBeforeWrap = iBufStart + iBufSize - iOutPtr; + + LOGTEXT2(_L8("\tiOutPtr=%d"), iOutPtr - iBufStart); + LOGTEXT2(_L8("\tiInPtr=%d"), iInPtr - iBufStart); + LOGTEXT2(_L8("\tiOffsetIntoClientsMemory=%d"), iOffsetIntoClientsMemory); + LOGTEXT2(_L8("\tlenBeforeWrap=%d"), lenBeforeWrap); + + if ( aLength > lenBeforeWrap ) + { + // We'll have to do this in two stages... + LOGTEXT(_L8("\twriting back in two stages")); + + __ASSERT_DEBUG(BufWrap(), + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + // Stage 1... + TPtrC8 ptrBeforeWrap(iOutPtr, lenBeforeWrap); + TInt err = iPort.IPCWrite(iCurrentRequest.iClientPtr, + ptrBeforeWrap, + iOffsetIntoClientsMemory); + LOGTEXT2(_L8("\tIPCWrite = %d"), err); + __ASSERT_DEBUG(!err, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + static_cast(err); + iOffsetIntoClientsMemory += lenBeforeWrap; + + // Stage 2... + TInt seg2Len = aLength - lenBeforeWrap; + TPtrC8 ptrAfterWrap(iBufStart, seg2Len); + err = iPort.IPCWrite(iCurrentRequest.iClientPtr, + ptrAfterWrap, + iOffsetIntoClientsMemory); + LOGTEXT2(_L8("\tIPCWrite = %d"), err); + __ASSERT_DEBUG(!err, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iOffsetIntoClientsMemory += seg2Len; + + // and set the pointers to show that we've consumed the data... + iOutPtr = iBufStart + seg2Len; + LOGTEXT(_L8("\twrite in two segments completed")); + } + else // We can do it in one go... + { + LOGTEXT(_L8("\twriting in one segment")); + + TPtrC8 ptr(iOutPtr, aLength); + TInt err = iPort.IPCWrite(iCurrentRequest.iClientPtr, + ptr, + iOffsetIntoClientsMemory); + LOGTEXT2(_L8("\tIPCWrite = %d"), err); + __ASSERT_DEBUG(!err, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + static_cast(err); + iOffsetIntoClientsMemory += aLength; + + // Set the pointers to show that we've consumed the data... + iOutPtr += aLength; + LOGTEXT(_L8("\twrite in one segment completed")); + } + + LOGTEXT2(_L8("\tiOutPtr=%d"), iOutPtr - iBufStart); + LOGTEXT2(_L8("\tiOffsetIntoClientsMemory=%d"), iOffsetIntoClientsMemory); + + // Adjust iLengthToGo + __ASSERT_DEBUG(iLengthToGo >= aLength, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iLengthToGo -= aLength; + } + +void CAcmReader::CompleteRequest(TInt aError) +/** + * Utility to reset our 'outstanding request' flag and complete the client's + * request back to them. Does not actually write back data to the client's + * address space. + * + * @param aError The error code to complete with. + */ + { + LOGTEXT2(_L8("CAcmReader::CompleteRequest aError=%d"), aError); + + // Set our flag to say that we no longer have an outstanding request. + iCurrentRequest.iClientPtr = NULL; + + if(ENotifyDataAvailable==iCurrentRequest.iRequestType) + { + LOGTEXT2(_L8("\tcalling NotifyDataAvailableCompleted with error %d"), aError); + iPort.NotifyDataAvailableCompleted(aError); + } + else // read and readoneormore + { + LOGTEXT2(_L8("\tcalling ReadCompleted with error %d"), aError); + iPort.ReadCompleted(aError); + } + } + +void CAcmReader::IssueRead() +/** + * Issues a read request for N bytes, where N is the minimum of iLengthToGo, + * the LDD's limit on Read requests, and how far we are from the end of our + * buffer. Used when trying to satisfy an RComm Read without terminators. + * We enforce that the buffer is empty, so we don't have to worry about the + * buffer being wrapped and the consequent risk of overwriting. + */ + { + LOG_FUNC + + CheckBufferEmptyAndResetPtrs(); + + LOGTEXT2(_L8("\tiBufSize = %d"), iBufSize); + LOGTEXT2(_L8("\tiInPtr = %d"), iInPtr - iBufStart); + + const TUint lenBeforeWrap = iBufStart + iBufSize - iInPtr; + + LOGTEXT2(_L8("\tiLengthToGo = %d"), iLengthToGo); + LOGTEXT2(_L8("\tlenBeforeWrap = %d"), lenBeforeWrap); + + const TUint limit = Min(static_cast(iLengthToGo), + static_cast(lenBeforeWrap)); + LOGTEXT2(_L8("\tissuing read for %d bytes"), limit); + iInBuf.Set(iInPtr, 0, limit); + __ASSERT_DEBUG(iPort.Acm(), + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iPort.Acm()->Read(*this, iInBuf, limit); + } + +void CAcmReader::IssueReadOneOrMore() +/** + * Issues a read request for N bytes, where N is the minimum of iLengthToGo, + * and how far we are from the end of our buffer. Used when trying to satisfy + * an RComm ReadOneOrMore. + * We enforce that the buffer is empty, so we don't have to worry about the + * buffer being wrapped and the consequent risk of overwriting. + */ + { + LOG_FUNC + + CheckBufferEmptyAndResetPtrs(); + + LOGTEXT2(_L8("\tiBufSize = %d"), iBufSize); + LOGTEXT2(_L8("\tiInPtr = %d"), iInPtr - iBufStart); + + const TUint lenBeforeWrap = iBufStart + iBufSize - iInPtr; + + LOGTEXT2(_L8("\tiLengthToGo = %d"), iLengthToGo); + LOGTEXT2(_L8("\tlenBeforeWrap = %d"), lenBeforeWrap); + + const TUint limit1 = Min(static_cast(lenBeforeWrap), iLengthToGo); + + LOGTEXT2(_L8("\tissuing read one or more for %d bytes"), limit1); + iInBuf.Set(iInPtr, 0, limit1); + __ASSERT_DEBUG(iPort.Acm(), + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iPort.Acm()->ReadOneOrMore(*this, iInBuf, limit1); + } + +TInt CAcmReader::FindTerminator() const +/** + * This function searches the circular buffer for one of a number of + * termination characters. + * The search is conducted between the read and write pointers. The function + * copes with the wrapping of the buffer. + * + * @return If positive: the number of bytes between where iOutPtr is pointing + * at and where the terminator was found inclusive. Takes wrapping into + * account. If negative: error. + */ + { + LOGTEXT(_L8(">>CAcmReader::FindTerminator")); + + TInt pos = 0; + TInt ret = KErrNone; + if ( !BufWrap() ) + { + ret = PartialFindTerminator(iOutPtr, iInPtr, pos); + if ( !ret ) + { + // Buffer wasn't wrapped, terminator found. + ret = pos; + } + } + else + { + ret = PartialFindTerminator(iOutPtr, iBufStart+iBufSize, pos); + if ( !ret ) + { + // Buffer was wrapped, but terminator was found in the section + // before the wrap. + ret = pos; + } + else + { + ret = PartialFindTerminator(iBufStart, iInPtr, pos); + if ( !ret ) + { + // Buffer was wrapped, terminator was found in the wrapped + // section. + const TUint lenBeforeWrap = iBufStart + iBufSize - iOutPtr; + ret = pos + lenBeforeWrap; + } + } + } + + // Check we're returning what we said we would. + __ASSERT_DEBUG(ret != KErrNone, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + LOGTEXT2(_L8("< +#include "AcmWriter.h" +#include "AcmPort.h" +#include "AcmPanic.h" +#include "AcmUtils.h" + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +CAcmWriter* CAcmWriter::NewL(CAcmPort& aPort, + TUint aBufSize) +/** + * Factory function. + * + * @param aPort Owning CAcmPort object. + * @param aBufSize Required buffer size. + * @return Ownership of a newly created CAcmWriter object + */ + { + LOG_STATIC_FUNC_ENTRY + + CAcmWriter* self = new(ELeave) CAcmWriter(aPort, aBufSize); + CleanupStack::PushL(self); + self->ConstructL(); + CLEANUPSTACK_POP(self); + return self; + } + +CAcmWriter::~CAcmWriter() +/** + * Destructor. + */ + { + LOG_FUNC + + WriteCancel(); + + delete iBuffer; + } + +void CAcmWriter::Write(const TAny* aClientBuffer, TUint aLength) +/** + * Queue a write. + * + * @param aClientBuffer pointer to the Client's buffer + * @param aLength Number of bytes to write + */ + { + LOGTEXT3(_L8("CAcmWriter::Write aClientBuffer=0x%08x, aLength=%d"), + aClientBuffer, aLength); + + // Check we're open to requests and make a note of interesting data. + CheckNewRequest(aClientBuffer, aLength); + + // If the write size greater than the current buffer size then the + // request will now complete over multiple operations. (This used to + // simply reject the write request with KErrNoMemory) + + // Get as much data as we can from the client into our buffer + ReadDataFromClient(); + // ...and write as much as we've got to the LDD + IssueWrite(); + } + +void CAcmWriter::WriteCancel() +/** + * Cancel a write. + */ + { + LOG_FUNC + + // Cancel any outstanding request on the LDD. + if ( iPort.Acm() ) + { + LOGTEXT(_L8("\tiPort.Acm() exists- calling WriteCancel on it")); + iPort.Acm()->WriteCancel(); + } + + // Reset our flag to say there's no current outstanding request. What's + // already in our buffer can stay there. + iCurrentRequest.iClientPtr = NULL; + } + +void CAcmWriter::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)); + + // Don't have anything to do. There are no pointers to reset. This + // function may in the future (if we support KConfigWriteBufferedComplete) + // do work, so leave the above assertion in. + } + +TInt CAcmWriter::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. + * + * @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(static_cast(aSize)); + if ( !newBuf ) + { + LOGTEXT(_L8("\tfailed to create new buffer- returning KErrNoMemory")); + return KErrNoMemory; + } + delete iBuffer; + iBuffer = newBuf; + iBuf.Set(iBuffer->Des()); + iBufSize = aSize; + + return KErrNone; + } + +CAcmWriter::CAcmWriter(CAcmPort& aPort, + TUint aBufSize) +/** + * Constructor. + * + * @param aPort The CPort parent. + * @param aBufSize The size of the buffer. + */ + : iBufSize(aBufSize), + iBuf(NULL,0,0), + iPort(aPort) + { + } + +void CAcmWriter::ConstructL() +/** + * 2nd-phase constructor. + */ + { + // Create the required buffer. + LOGTEXT(_L8("\tabout to create iBuffer")); + LEAVEIFERRORL(SetBufSize(iBufSize)); + } + +void CAcmWriter::WriteCompleted(TInt aError) +/** + * This function is called when a write on the LDD has completed. + * This checks whether any data remains to be written, if so the + * read and write requests are re-issued until there in no data + * left or an error occurs. + * + * @param aError Error with which the write completed. + */ + { + LOG_FUNC + LOGTEXT2(_L8("\taError=%d"), aError); + + if(iLengthToGo == 0 || aError != KErrNone) + { + LOGTEXT2(_L8("\tcompleting request with %d"), aError); + CompleteRequest(aError); + } + else + { + //there is some data remaining to be read so reissue the Read & Write + //requests until there is no data left. + ReadDataFromClient(); + IssueWrite(); + } + } + +void CAcmWriter::ReadDataFromClient() +/** + * Read data from the client space into the internal buffer, prior to writing. + */ + { + LOG_FUNC + TPtr8 ptr((TUint8*)iBuf.Ptr(), + 0, + Min(iBuf.MaxLength(), iLengthToGo)); + + TInt err = iPort.IPCRead(iCurrentRequest.iClientPtr, + ptr, + static_cast(iOffsetIntoClientsMemory)); + LOGTEXT2(_L8("\tIPCRead = %d"), err); + iBuf.SetLength(ptr.Length()); + __ASSERT_DEBUG(!err, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + static_cast(err); + + // Increase our pointer (into the client's space) of already-read data. + iOffsetIntoClientsMemory += iBuf.Length(); + } + + + +void CAcmWriter::CheckNewRequest(const TAny* aClientBuffer, TUint aLength) +/** + * Utility function to check a new 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 aLength Length to write. + */ + { + LOG_FUNC + + __ASSERT_DEBUG(aLength <= static_cast(KMaxTInt), + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + // Check we have no outstanding request already. + if ( iCurrentRequest.iClientPtr ) + { + _USB_PANIC(KAcmPanicCat, EPanicInternalError); + } + // Sanity check on what C32 gave us. + __ASSERT_DEBUG(aClientBuffer, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + // Make a note of interesting data. + iCurrentRequest.iLength = aLength; + iCurrentRequest.iClientPtr = aClientBuffer; + + iLengthToGo = aLength; + iOffsetIntoClientsMemory = 0; + } + +void CAcmWriter::CompleteRequest(TInt aError) +/** + * Utility to reset our 'outstanding request' flag and complete the client's + * request back to them. + * + * @param aError The error code to complete with. + */ + { + LOGTEXT2(_L8("CAcmWriter::CompleteRequest aError=%d"), aError); + + // Set our flag to say that we no longer have an outstanding request. + iCurrentRequest.iClientPtr = NULL; + + LOGTEXT2(_L8("\tcalling WriteCompleted with %d"), aError); + iPort.WriteCompleted(aError); + } + +void CAcmWriter::IssueWrite() +/** + * Writes a batch of data from our buffer to the LDD. Currently writes the + * entire load of buffered data in one go. + */ + { + LOG_FUNC + + LOGTEXT2(_L8("\tissuing Write of %d bytes"), iBuf.Length()); + __ASSERT_DEBUG(iPort.Acm(), + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iPort.Acm()->Write(*this, + iBuf, + iBuf.Length()); + +#ifdef DEBUG + // A Zero Length Packet is an acceptable packet so iBuf.Length == 0 is acceptable, + // if we receive this and the request length > 0 then we may have a problem so check + // that the LengthToGo is also 0, if it is not then we may end up looping through this + // code until a driver write error occurs which may never happen. + // This is not expected to occur but the test is in here just to be safe. + if(iBuf.Length() == 0 && iCurrentRequest.Length() != 0 && iLengthToGo != 0) + { + _USB_PANIC(KAcmPanicCat, EPanicInternalError); + } +#endif + // Update our counter of remaining data to write. + iLengthToGo -= iBuf.Length(); + } + +// +// End of file diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/ActiveDataAvailableNotifier.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/ActiveDataAvailableNotifier.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,168 @@ +/* +* Copyright (c) 2007-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 +#include +#include "ActiveDataAvailableNotifier.h" +#include "AcmConstants.h" +#include "AcmPanic.h" +#include "AcmUtils.h" +#include "NotifyDataAvailableObserver.h" +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +CActiveDataAvailableNotifier::CActiveDataAvailableNotifier( + MNotifyDataAvailableObserver& aParent, + RDevUsbcClient& aLdd, + TEndpointNumber aEndpoint) + : CActive(KEcacmAOPriority), + iParent(aParent), + iLdd(aLdd), + iEndpoint(aEndpoint) +/** + * Constructor. + * + * @param aParent The object that will be notified if a + * NotifyDataAvailable() request has been made and incoming data + * arrives at the LDD. + * @param aLdd The LDD handle to be used for posting read requests. + * @param aEndpoint The endpoint to read from. + */ + { + CActiveScheduler::Add(this); + } + +CActiveDataAvailableNotifier::~CActiveDataAvailableNotifier() +/** + * Destructor. + */ + { + LOG_FUNC + + Cancel(); + } + +CActiveDataAvailableNotifier* CActiveDataAvailableNotifier::NewL( + MNotifyDataAvailableObserver& aParent, + RDevUsbcClient& aLdd, + TEndpointNumber aEndpoint) +/** + * Standard two phase constructor. + * + * @param aParent The object that will be notified if a + * NotifyDataAvailable() request has been made and incoming data + * arrives at the LDD. + * @param aLdd The LDD handle to be used for posting read requests. + * @param aEndpoint The endpoint to read from. + * @return Ownership of a new CActiveReadOneOrMoreReader object. + */ + { + LOG_STATIC_FUNC_ENTRY + + CActiveDataAvailableNotifier* self = + new(ELeave) CActiveDataAvailableNotifier(aParent, aLdd, aEndpoint); + return self; + } + +void CActiveDataAvailableNotifier::NotifyDataAvailable() +/** + * When incoming data arrives at the LDD notify the caller. + */ + { + LOGTEXT(_L8(">>CActiveDataAvailableNotifier::NotifyDataAvailable")); + + iLdd.ReadOneOrMore(iStatus, iEndpoint, iUnusedBuf, 0); + SetActive(); + + LOGTEXT(_L8("< +#include +#include "ActiveReadOneOrMoreReader.h" +#include "AcmConstants.h" +#include "AcmPanic.h" +#include "AcmUtils.h" +#include "ReadOneOrMoreObserver.h" +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +CActiveReadOneOrMoreReader::CActiveReadOneOrMoreReader( + MReadOneOrMoreObserver& aParent, + RDevUsbcClient& aLdd, + TEndpointNumber aEndpoint) + : CActive(KEcacmAOPriority), + iParent(aParent), + iLdd(aLdd), + iEndpoint(aEndpoint) +/** + * Constructor. + * + * @param aParent The object that will be notified when read requests + * complete. + * @param aLdd The LDD handle to be used for posting read requests. + * @param aEndpoint The endpoint to read from. + */ + { + CActiveScheduler::Add(this); + } + +CActiveReadOneOrMoreReader::~CActiveReadOneOrMoreReader() +/** + * Destructor. + */ + { + LOG_FUNC + + Cancel(); + } + +CActiveReadOneOrMoreReader* CActiveReadOneOrMoreReader::NewL( + MReadOneOrMoreObserver& aParent, + RDevUsbcClient& aLdd, + TEndpointNumber aEndpoint) +/** + * Standard two phase constructor. + * + * @param aParent The object that will be notified when read requests + * complete. + * @param aLdd The LDD handle to be used for posting read requests. + * @param aEndpoint The endpoint to read from. + * @return Ownership of a new CActiveReadOneOrMoreReader object. + */ + { + LOG_STATIC_FUNC_ENTRY + + CActiveReadOneOrMoreReader* self = + new(ELeave) CActiveReadOneOrMoreReader(aParent, aLdd, aEndpoint); + return self; + } + +void CActiveReadOneOrMoreReader::ReadOneOrMore(TDes8& aDes, TInt aLength) +/** + * Read as much data as the LDD can supply up to the given limit. + * + * @param aDes A descriptor into which the data will be read. + * @param aLength The length to read. + */ + { + LOGTEXT2(_L8(">>CActiveReadOneOrMoreReader::ReadOneOrMore " + "aLength=%d"), aLength); + + iLdd.ReadOneOrMore(iStatus, iEndpoint, aDes, aLength); + SetActive(); + + LOGTEXT(_L8("<>CActiveReadOneOrMoreReader::RunL iStatus=%d"), + iStatus.Int()); + + iParent.ReadOneOrMoreCompleted(iStatus.Int()); + + LOGTEXT(_L8("< +#include +#include "ActiveReader.h" +#include "AcmConstants.h" +#include "AcmPanic.h" +#include "ReadObserver.h" +#include "AcmUtils.h" +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +CActiveReader::CActiveReader(MReadObserver& aParent, RDevUsbcClient& aLdd, TEndpointNumber aEndpoint) + : CActive(KEcacmAOPriority), + iParent(aParent), + iLdd(aLdd), + iEndpoint(aEndpoint) +/** + * Constructor. + * + * @param aParent The object that will be notified when read requests + * complete. + * @param aLdd The LDD handle to be used for posting read requests. + * @param aEndpoint The endpoint to read from. + */ + { + CActiveScheduler::Add(this); + } + +CActiveReader::~CActiveReader() +/** + * Destructor. + */ + { + LOG_FUNC + + Cancel(); + } + +CActiveReader* CActiveReader::NewL(MReadObserver& aParent, + RDevUsbcClient& aLdd, + TEndpointNumber aEndpoint) +/** + * Standard two phase constructor. + * + * @param aParent The object that will be notified when read requests + * complete. + * @param aLdd The LDD handle to be used for posting read requests. + * @param aEndpoint The endpoint to read from. + * @return Ownership of a new CActiveReader object. + */ + { + LOG_STATIC_FUNC_ENTRY + + CActiveReader* self = new(ELeave) CActiveReader(aParent, aLdd, aEndpoint); + return self; + } + +void CActiveReader::Read(TDes8& aDes, TInt aLen) +/** + * Read the given length of data from the LDD. + * + * @param aDes A descriptor into which to read. + * @param aLen The length to read. + */ + { + LOG_FUNC + + iLdd.Read(iStatus, iEndpoint, aDes, aLen); + SetActive(); + } + +void CActiveReader::DoCancel() +/** + * Cancel an outstanding read. + */ + { + LOG_FUNC + + iLdd.ReadCancel(iEndpoint); + } + +void CActiveReader::RunL() +/** + * This function will be called when the read completes. It notifies the + * parent class of the completion. + */ + { + LOG_LINE + LOGTEXT2(_L8(">>CActiveReader::RunL iStatus=%d"), iStatus.Int()); + + iParent.ReadCompleted(iStatus.Int()); + + LOGTEXT(_L8("< +#include +#include "ActiveWriter.h" +#include "AcmConstants.h" +#include "AcmPanic.h" +#include "WriteObserver.h" +#include "AcmUtils.h" +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +CActiveWriter::CActiveWriter(MWriteObserver& aParent, RDevUsbcClient& aLdd, TEndpointNumber aEndpoint) + : CActive(KEcacmAOPriority), + iParent(aParent), + iLdd(aLdd), + iEndpoint(aEndpoint), + iFirstPortion(NULL, 0), + iSecondPortion(NULL, 0) +/** + * Constructor. + * + * @param aParent The object that will be notified when write requests + * complete. + * @param aLdd The LDD handle to be used for posting write requests. + * @param aEndpoint The endpoint to write to. + */ + { + CActiveScheduler::Add(this); + } + +CActiveWriter::~CActiveWriter() +/** + * Destructor. + */ + { + LOG_FUNC + + Cancel(); + } + +CActiveWriter* CActiveWriter::NewL(MWriteObserver& aParent, + RDevUsbcClient& aLdd, + TEndpointNumber aEndpoint) +/** + * Standard two phase constructor. + * + * @param aParent The object that will be notified when write requests + * complete. + * @param aLdd The LDD handle to be used for posting write requests. + * @param aEndpoint The endpoint to write to. + * @return Ownership of a new CActiveWriter object. + */ + { + LOG_STATIC_FUNC_ENTRY + + CActiveWriter* self = new(ELeave) CActiveWriter(aParent, aLdd, aEndpoint); + return self; + } + +void CActiveWriter::Write(const TDesC8& aDes, + TInt aLen, + TBool aZlp) +/** + * Write the given data to the LDD. + * + * @param aDes A descriptor to write. + * @param aLen The length to write. + * @param aZlp Whether ZLP termination may be required. + */ + { + LOGTEXT(_L8(">>CActiveWriter::Write")); + + if ( aZlp ) + { + // the driver can be relied on to correctly handle appended ZLPs + // so use them when necessary.. + iLdd.Write(iStatus, iEndpoint, aDes, aLen, ETrue); + iWritingState = ECompleteMessage; + } + else + { + // do we need to send this descriptor in two portions to + // avoid finishing the last packet on a 64 byte boundary ( avoiding + // expectations of a ZLP by drivers that would handle them ) ? + + // If the write request is for zero bytes a 'split' would be erroneous. + TBool full64BytePacket = ( aLen % KMaxPacketSize ) ? EFalse : ETrue; + + if ( full64BytePacket == EFalse || aLen == 0 ) + { + iLdd.Write(iStatus, iEndpoint, aDes, aLen, EFalse); + iWritingState = ECompleteMessage; + LOGTEXT2(_L8("CActiveWriter::Writing %d bytes"), aLen); + } + else + { + // we do need to split the descriptor, sending aLen-1 bytes now + // and sending a second portion with the remaining 1 byte later + iFirstPortion.Set(aDes.Left(aLen-1)); + + // Use of Left here ensures that if we've been passed a descriptor + // longer than aLen (doesn't *currently* happen), we don't corrupt + // data. + iSecondPortion.Set(aDes.Left(aLen).Right(1)); + + iLdd.Write(iStatus, iEndpoint, iFirstPortion, aLen-1, EFalse); + + iWritingState = EFirstMessagePart; + LOGTEXT3(_L8("CActiveWriter::Writing %d bytes of the %d"), aLen-1, aLen); + } + } + SetActive(); + + LOGTEXT(_L8("<>CActiveWriter::RunL iStatus=%d"), iStatus.Int()); + + if ( iWritingState == EFirstMessagePart ) + { + if ( iStatus.Int() == KErrNone ) + { + // now send the second part.. + iLdd.Write(iStatus, iEndpoint, iSecondPortion, iSecondPortion.Length(), EFalse); + iWritingState = EFinalMessagePart; + LOGTEXT(_L8("CActiveWriter::Writing 1 byte to complete original nx64 byte message")); + + SetActive(); + } + else + { + // the writing of the first part failed + iParent.WriteCompleted(iStatus.Int()); + } + } + else + { + // iWritingState == ECompleteMessage or EFinalMessagePart + iParent.WriteCompleted(iStatus.Int()); + } + + LOGTEXT(_L8("< + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +CBreakController::CBreakController(CCdcAcmClass& aParentAcm) +/** + * Constructor. + * + * @param aParentAcm Observer. + */ + : CActive(CActive::EPriorityStandard), + iBreakState(EInactive), + iParentAcm(aParentAcm) + { + CActiveScheduler::Add(this); + + // now populate the state machine that manages the transfers between + // the declared state values of TBreakState. + TInt oldBS; + TInt newBS; + + for ( oldBS = 0 ; oldBS < ENumStates ; oldBS++ ) + { + for ( newBS = 0 ; newBS < ENumStates ; newBS++ ) + { + StateDispatcher[oldBS][newBS] = ScInvalid; + } + } + + // Note that these state transitions are the simple states of the machine. + // Checking which entity is currently in control of the break (if any) is + // done elsewhere. + // Old State -> New State + // | | + StateDispatcher[EInactive ][ETiming ] = &ScSetTimer; + StateDispatcher[EInactive ][ELocked ] = &ScLocked; + + StateDispatcher[ETiming ][EInactive ] = &ScInactive; + StateDispatcher[ETiming ][ETiming ] = &ScSetTimer; + StateDispatcher[ETiming ][ELocked ] = &ScLocked; + + StateDispatcher[ELocked ][EInactive ] = &ScInactive; + StateDispatcher[ELocked ][ETiming ] = &ScSetTimer; + } + +CBreakController* CBreakController::NewL(CCdcAcmClass& aParentAcm) +/** + * Factory function. + * + * @param aParentAcm Parent. + * @return Ownership of a new CBreakController object. + */ + { + LOG_STATIC_FUNC_ENTRY + + CBreakController* self = new(ELeave) CBreakController(aParentAcm); + CleanupStack::PushL(self); + self->ConstructL(); + CLEANUPSTACK_POP(self); + return self; + } + +void CBreakController::ConstructL() +/** + * 2nd-phase constructor. + */ + { + LEAVEIFERRORL(iTimer.CreateLocal()); + } + +CBreakController::~CBreakController() +/** + * Destructor. + */ + { + LOG_FUNC + + Cancel(); + iTimer.Close(); + } + +void CBreakController::RunL() +/** + * Called by the active scheduler; handles timer completion. + */ + { + LOG_LINE + LOG_FUNC + + // check the status to see if the timer has matured, if so go straight + // to INACTIVE state (and publish new state) + if ( iStatus == KErrNone ) + { + // Use iRequester to turn the break off. This should not fail. + TInt err = BreakRequest(iRequester, EInactive); + static_cast(err); + __ASSERT_DEBUG(!err, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + } + } + +void CBreakController::DoCancel() +/** + * Called by the framework; handles cancelling the outstanding timer request. + */ + { + LOG_FUNC + + iTimer.Cancel(); + } + +TInt CBreakController::BreakRequest(TRequester aRequester, + TState aState, + TTimeIntervalMicroSeconds32 aDelay) +/** + * Make a break-related request. + * + * @param aRequester The entity requesting the break. + * @param aState The request- either a locked break, a timed break, or to + * make the break inactive. + * @param aDelay The time delay, only used for a timed break. + * @return Error, for instance if a different entity already owns the break. + */ + { + LOG_FUNC + LOGTEXT4(_L8("\taRequester = %d, aState = %d, aDelay = %d"), + aRequester, aState, aDelay.Int()); + + // Check the validity of the request. + if ( aRequester != iRequester && iRequester != ENone ) + { + LOGTEXT3(_L8("\t*** %d is in charge- cannot service request " + "from %d- returning KErrInUse"), iRequester, aRequester); + return KErrInUse; + } + + iRequester = aRequester; + + StateMachine(aState, aDelay); + + // Reset the owner member if relevant. + if ( aState == EInactive ) + { + iRequester = ENone; + } + + return KErrNone; + } + +void CBreakController::StateMachine(TState aBreakState, + TTimeIntervalMicroSeconds32 aDelay) +/** + * The generic BREAK state machine. + * + * @param aBreakState The state to go to now. + * @param aDelay Only used if going to a breaking state, the delay. + */ + { + LOG_FUNC + + TBool resultOK = EFalse; + + // Invoke the desired function. + PBFNT pfsDispatch = StateDispatcher[iBreakState][aBreakState]; + __ASSERT_DEBUG(pfsDispatch, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + resultOK = ( *pfsDispatch )(this, aDelay); + + if ( resultOK ) + { + LOGTEXT(_L8("\tbreak state dispatcher returned *SUCCESS*")); + + // check to see if the state change will need to result + // in a modification to the public state of BREAK which is + // either NO-BREAK == EBreakInactive + // or BREAK-ON == (anything else) + if( ( iBreakState != aBreakState ) + && ( + ( iBreakState == EInactive ) + || ( aBreakState == EInactive ) + ) + ) + { + Publish(aBreakState); + } + + // accept the state change ready for next time + iBreakState = aBreakState; + } + else + { + LOGTEXT(_L8("\tbreak state dispatcher returned *FAILURE*")); + } + } + +void CBreakController::Publish(TState aNewState) +/** + * Pointer-safe method to inform the (USB) Host and the Client of BREAK + * changes. + * + * @param aNewState The next state we're about to go to. + */ + { + LOG_FUNC + LOGTEXT2(_L8("\taNewState = %d"), aNewState); + + __ASSERT_DEBUG(aNewState != iBreakState, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + // send the new BREAK state off to the USB Host + // this function is normally used so that ACMCSY can send client + // changes to RING, DSR and DCD to the USB Host, however we use + // it here to force it to refresh all states together with the + // new BREAK state. + // TODO: check return value + iParentAcm.SendSerialState( + iParentAcm.RingState(), + iParentAcm.DsrState(), + iParentAcm.DcdState()); + + // inform the ACM Class client that the BREAK signal has just changed, + // this should cause it to be toggled there. + if( iParentAcm.BreakCallback() ) + { + LOGTEXT(_L8("\tabout to call back break state change")); + iParentAcm.BreakCallback()->BreakStateChange(); + } + + // If we're going to the inactive state, and if the device is interested, + // we tell the MBreakObserver (ACM port) that the break has completed. + if ( aNewState == EInactive ) + { + LOGTEXT(_L8("\tnew state is break-inactive")); + if ( iRequester == EDevice ) + { + LOGTEXT(_L8("\tdevice is interested")); + if( iParentAcm.BreakCallback() ) + { + LOGTEXT(_L8("\tabout to call back break completion")); + iParentAcm.BreakCallback()->BreakRequestCompleted(); + } + } + + // We just got to break-inactive state. Blank the requester record. + iRequester = ENone; + } + } + +/** + * +----------------------------------------------+ + * | Set of state-machine functions to be used in | + * | a two-dimensional dispatcher matrix | + * +----------------------------------------------+ + */ + +TBool CBreakController::ScInvalid(CBreakController *aThis, + TTimeIntervalMicroSeconds32 aDelay) + { + LOG_STATIC_FUNC_ENTRY + + static_cast(aThis); // remove warning + static_cast(aDelay); // remove warning + + return( EFalse ); + } + +TBool CBreakController::ScInactive(CBreakController *aThis, + TTimeIntervalMicroSeconds32 aDelay) + { + LOG_STATIC_FUNC_ENTRY + + static_cast(aDelay); // remove warning + + // this may have been called while a BREAK is already current, cancel the + // timer. + aThis->Cancel(); + + aThis->iParentAcm.SetBreakActive(EFalse); + + return( ETrue ); + } + +TBool CBreakController::ScSetTimer(CBreakController *aThis, + TTimeIntervalMicroSeconds32 aDelay) + { + LOG_STATIC_FUNC_ENTRY + + // don't try to set any delay if the caller wants something impossible + if ( aDelay.Int() <= 0 ) + { + return( EFalse ); + } + + aThis->Cancel(); // in case we're already active. + + aThis->iTimer.After(aThis->iStatus, aDelay); + aThis->SetActive(); + + aThis->iParentAcm.SetBreakActive(ETrue); + + return( ETrue ); + } + +TBool CBreakController::ScLocked(CBreakController *aThis, + TTimeIntervalMicroSeconds32 aDelay) + { + LOG_STATIC_FUNC_ENTRY + + static_cast(aDelay); // remove warning + + // this may have been called while a BREAK is already current, so cancel + // the timer. + aThis->Cancel(); + + aThis->iParentAcm.SetBreakActive(ETrue); + + return( ETrue ); + } + +// +// End of file diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/CdcAcmClass.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/CdcAcmClass.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,1077 @@ +/* +* 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: +* +*/ + +#include "CdcAcmClass.h" +#include "CdcControlInterface.h" +#include "CdcDataInterface.h" +#include "AcmPanic.h" +#include "AcmUtils.h" +#include "HostPushedChangeObserver.h" +#include "BreakController.h" +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +CCdcAcmClass::CCdcAcmClass() +/** + * Constructor. + */ + { + SetDefaultAcm(); + } + +CCdcAcmClass* CCdcAcmClass::NewL(const TUint8 aProtocolNum, const TDesC16& aAcmControlIfcName, const TDesC16& aAcmDataIfcName) +/** + * Create a new CCdcAcmClass object + * + * @return Ownership of a new CCdcAcmClass object + */ + { + LOG_STATIC_FUNC_ENTRY + + CCdcAcmClass* self = new(ELeave) CCdcAcmClass; + CleanupStack::PushL(self); + self->ConstructL(aProtocolNum, aAcmControlIfcName, aAcmDataIfcName); + CLEANUPSTACK_POP(self); + return self; + } + +void CCdcAcmClass::ConstructL(const TUint8 aProtocolNum, const TDesC16& aControlIfcName, const TDesC16& aDataIfcName) +/** + * 2nd-phase construction. Creates both the control and data objects. + * @param aProtocolNum contains the Table 17 protocol number. + * @param aControlIfcName contains the interface name + * @param aDataIfcName contains the interface name + */ + { + TUint8 interfaceNumber; + TInt res; + + LOGTEXT(_L8("\tabout to create control interface with name")); + iControl = CCdcControlInterface::NewL(*this, aProtocolNum, aControlIfcName); + + LOGTEXT(_L8("\tabout to create data interface with name")); + iData = CCdcDataInterface::NewL(aDataIfcName); + + iBreakController = CBreakController::NewL(*this); + + LOGTEXT(_L8("\tabout to call GetInterfaceNumber")); + res = iData->GetInterfaceNumber(interfaceNumber); + if ( res ) + { + LOGTEXT2(_L8("\tGetInterfaceNumber=%d"), res); + LEAVEIFERRORL(res); + } + + LOGTEXT(_L8("\tabout to call SetupClassSpecificDescriptor")); + res = iControl->SetupClassSpecificDescriptor(interfaceNumber); + if ( res ) + { + LOGTEXT2(_L8("\tSetupClassSpecificDescriptor=%d"), res); + LEAVEIFERRORL(res); + } + } + +CCdcAcmClass::~CCdcAcmClass() +/** + * Destructor. + */ + { + LOG_FUNC + + delete iControl; + delete iData; + delete iBreakController; + } + +void CCdcAcmClass::SetCallback(MHostPushedChangeObserver* aCallback) +/** + * Set the ACM class callback object. This cannot be done at construction + * because the ACM class and the port have different lifetimes. + */ + { + LOGTEXT2(_L8(">>CCdcAcmClass::SetCallback aCallback=0x%08x"), aCallback); + + iCallback = aCallback; + + // remember that this function can also be called to + // unset the callback when it is given a NULL pointer + if ( iCallback ) + { + // send off whatever has been seen from Host + // requests to change the line coding + TCommConfigV01 epocConfig; + ConvertUsbConfigCodingToEpoc(iUsbConfig,epocConfig); + iCallback->HostConfigChange(epocConfig); + + // send off whatever has been seen from Host + // requests to set the control line state + iCallback->HostSignalChange(iDtrState,iRtsState); + } + + LOGTEXT(_L8("<>CCdcAcmClass::SetBreakCallback aBreakCallback=0x%08x"), + aBreakCallback); + + iBreakCallback = aBreakCallback; + + LOGTEXT(_L8("<>CCdcAcmClass::ReadOneOrMore aObserver=0x%08x"), + &aObserver); + + ReadOneOrMore(aObserver, aDes, aDes.Length()); + + LOGTEXT(_L8("<>CCdcAcmClass::ReadOneOrMore aObserver=0x%08x, " + "aLength=%d"), + &aObserver, aLength); + + __ASSERT_DEBUG(iData, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iData->ReadOneOrMore(aObserver, aDes, aLength); + + LOGTEXT(_L8("<>CCdcAcmClass::Read aObserver=0x%08x"), &aObserver); + + Read(aObserver, aDes, aDes.Length()); + + LOGTEXT(_L8("<>CCdcAcmClass::Read aObserver=0x%08x, aLength=%d"), + &aObserver, aLength); + + __ASSERT_DEBUG(iData, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iData->Read(aObserver, aDes, aLength); + + LOGTEXT(_L8("<CancelRead(); + } + +void CCdcAcmClass::Write(MWriteObserver& aObserver, const TDesC8& aDes) +/** + * Write to the bus. + * + * @param aObserver The observer to notify completion to. + * @param aDes Descriptor containing the data to be written. + */ + { + LOGTEXT2(_L8(">>CCdcAcmClass::Write aObserver=0x%08x"), + &aObserver); + + Write(aObserver, aDes, aDes.Length()); + + LOGTEXT(_L8("<>CCdcAcmClass::Write aObserver=0x%08x, aLength=%d"), + &aObserver, aLength); + + __ASSERT_DEBUG(iData, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iData->Write(aObserver, aDes, aLength); + + LOGTEXT(_L8("<CancelWrite(); + } + +TInt CCdcAcmClass::HandleGetCommFeature(const TUint16 aSelector, + TDes8& aReturnData) +/** + * Callback for Get Comm Feature requests. + * + * @param aSelector Multiplex control for the feature is held in wValue field + * @param aReturnData Descriptor containing the multiplexed and idle state of + * the ACM device or the country code from ISO 3166. + */ + { + LOGTEXT2(_L8(">>CCdcAcmClass::HandleGetCommFeature aSelector=%d"), + aSelector); + + TInt ret = KErrNone; + + // check the feature selector from the header and reject if invalid, + // otherwise deal with it. + switch ( aSelector ) + { + case EUsbCommFeatureSelectAbstractState: + { + aReturnData.SetLength(2); + + TUint8* pbuffer; + TUint8** ppbuffer; + pbuffer = &aReturnData[0]; + ppbuffer = &pbuffer; + + CCdcControlInterface::PutU16(ppbuffer,iAcmState); + + LOGTEXT2(_L8("\tAbstract State [0x%04X]"), iAcmState); + } + break; + + case EUsbCommFeatureSelectCountryCode: + { +#if defined(DISABLE_ACM_CF_COUNTRY_SETTING) + + aReturnData.SetLength(0); + LOGTEXT(_L8("\tCountry Code Not Supported")); + ret = KErrNotSupported; + +#elif defined(ENABLE_ACM_CF_COUNTRY_SETTING) + + aReturnData.SetLength(2); + + TUint8* pbuffer; + TUint8** ppbuffer; + pbuffer = &aReturnData[0]; + ppbuffer = &pbuffer; + + CCdcControlInterface::PutU16(ppbuffer,iCountryCode); + + LOGTEXT2(_L8("\tCountry Code [0x%04X]"), iCountryCode); + +#endif + } + break; + + default: + aReturnData.SetLength(0); + LOGTEXT(_L8("\tBad Selector")); + ret = KErrUnknown; + } + + LOGTEXT2(_L8("<>CCdcAcmClass::HandleClearCommFeature aSelector=%d"), + aSelector); + + TInt ret = KErrNone; + + // check the feature selector from the header and reject if invalid, + // otherwise deal with it. + switch ( aSelector ) + { + case EUsbCommFeatureSelectAbstractState: + { + // reset to guaranteed-success default, so ignore return value + static_cast(HandleNewAbstractState(EUsbAbstractStateDataMultiplex)); + LOGTEXT2(_L8("\tAbstract State [0x%04X]"), iAcmState); + } + break; + + case EUsbCommFeatureSelectCountryCode: + { +#if defined(DISABLE_ACM_CF_COUNTRY_SETTING) + + LOGTEXT(_L8("\tCountry Code Not Supported")); + ret = KErrNotSupported; + +#elif defined(ENABLE_ACM_CF_COUNTRY_SETTING) + + HandleNewCountryCode(KUsbCommCountryCode0); + LOGTEXT2(_L8("\tCountry Code [0x%04X]"), iCountryCode); + +#endif + } + break; + + default: + { + LOGTEXT(_L8("\tBad Selector")); + ret = KErrUnknown; + } + } + + LOGTEXT2(_L8("<(&aData[0]); + ppbuffer = &pbuffer; + + iUsbConfig.iRate = CCdcControlInterface::GetU32(ppbuffer); + iUsbConfig.iStopBits = static_cast(CCdcControlInterface::GetU08(ppbuffer)); + iUsbConfig.iParity = static_cast(CCdcControlInterface::GetU08(ppbuffer)); + iUsbConfig.iDataBits = static_cast(CCdcControlInterface::GetU08(ppbuffer)); + + if ( iCallback ) + { + TCommConfigV01 epocConfig; + + ConvertUsbConfigCodingToEpoc(iUsbConfig, epocConfig); + + iCallback->HostConfigChange(epocConfig); + } + + return KErrNone; + } + +void CCdcAcmClass::SetDefaultAcm() +/** + * Reset the data fields to a set of known default values. Will be used when + * we implement restart, which involves a host re-enumeration without + * destroying the ACM class, so we need a function to reset the ACM to + * defaults. + */ + { + iUsbConfig.iRate = 115200; + iUsbConfig.iStopBits = EUsbStopBitOne; + iUsbConfig.iParity = EUsbParityNone; + iUsbConfig.iDataBits = EUsbDataBitsEight; + + iAcmState = EUsbAbstractStateDataMultiplex; + iCountryCode = 0x2A2A; // 0x2A2A is "**"- just an invalid code + + iAcmDataMultiplex = (iAcmState & EUsbAbstractStateDataMultiplex) + ? ETrue : EFalse; + iAcmIdleSetting = (iAcmState & EUsbAbstractStateIdleSetting) + ? ETrue : EFalse; + + iRtsState = EFalse; + iDtrState = EFalse; + + iRingState = EFalse; + iDsrState = EFalse; + iDcdState = EFalse; + + iBreakActive = EFalse; + } + +void CCdcAcmClass::ConvertUsbConfigCodingToEpoc(const TUsbConfig& aUsbConfig, + TCommConfigV01& aEpocConfig) +/** + * Convert configuration information received from a Host in "USB" format to + * the native "EPOC" configuration format. + * + * @param aUsbConfig The USB configuration to be converted from. + * @param aEpocConfig The EPOC configuration to be converted to. + */ + { + switch ( aUsbConfig.iDataBits ) + { + case EUsbDataBitsFive: + aEpocConfig.iDataBits = EData5; + break; + + case EUsbDataBitsSix: + aEpocConfig.iDataBits = EData6; + break; + + case EUsbDataBitsSeven: + aEpocConfig.iDataBits = EData7; + break; + + case EUsbDataBitsEight: + aEpocConfig.iDataBits = EData8; + break; + + // EPOC doesn't support this, so map it to "8" for the time being... + case EUsbDataBitsSixteen: + aEpocConfig.iDataBits = EData8; + break; + + // Map any other signals to "8"... + default: + aEpocConfig.iDataBits = EData8; + break; + } + + switch ( aUsbConfig.iStopBits ) + { + case EUsbStopBitOne: + aEpocConfig.iStopBits = EStop1; + break; + + // EPOC doesn't have any "1.5" setting, so go for "1". + case EUsbStopBitOnePtFive: + aEpocConfig.iStopBits = EStop1; + break; + + case EUsbStopBitTwo: + aEpocConfig.iStopBits = EStop2; + break; + + // Map any other signals to "1"... + default: + aEpocConfig.iStopBits = EStop1; + break; + } + + switch ( aUsbConfig.iParity ) + { + case EUsbParityNone: + aEpocConfig.iParity = EParityNone; + break; + + case EUsbParityOdd: + aEpocConfig.iParity = EParityOdd; + break; + + case EUsbParityEven: + aEpocConfig.iParity = EParityEven; + break; + + case EUsbParityMark: + aEpocConfig.iParity = EParityMark; + break; + + case EUsbParitySpace: + aEpocConfig.iParity = EParitySpace; + break; + + // Map any other signals to "No Parity"... + default: + aEpocConfig.iParity = EParityNone; + break; + } + + static const TUint32 KUsbDataRate[] = { 50, 75, 110, + 134, 150, 300, + 600, 1200, 1800, + 2000, 2400, 3600, + 4800, 7200, 9600, + 19200, 38400, 57600, + 115200,230400, 460800, + 576000,1152000,4000000}; + + static const TBps KEpocDataRate[] = { EBps50, EBps75, EBps110, + EBps134, EBps150, EBps300, + EBps600, EBps1200, EBps1800, + EBps2000, EBps2400, EBps3600, + EBps4800, EBps7200, EBps9600, + EBps19200, EBps38400, EBps57600, + EBps115200,EBps230400, EBps460800, + EBps576000,EBps1152000,EBps4000000}; + + aEpocConfig.iRate = EBpsSpecial; // Default to "Special" + TInt arraySize = sizeof(KUsbDataRate)/sizeof(TUint32); + for ( TInt i = 0 ; i < arraySize ; i++ ) + { + if ( aUsbConfig.iRate == KUsbDataRate[i] ) + { + aEpocConfig.iRate = KEpocDataRate[i]; + break; + } + } + } + +TInt CCdcAcmClass::HandleNewAbstractState(const TUint16 aAbstractState) +/** + * Handle new Abstract State as received from Host, check values + * and inform client watcher (if registered) + * @param aAbstractState The new Abstract State which contains + * significant bits D0 and D1 where: + * + * D0 controls 'idle setting' -> iAcmIdleSetting + * D1 controls 'data multiplexed state' -> iAcmDataMultiplex + */ + { + LOGTEXT2(_L8(">>CCdcAcmClass::HandleNewAbstractState aAbstractState=%d"), + aAbstractState); + + TBool multiplex; + TBool idle; + + TUint16 newstate; + + TInt ret; + + // collect local booleans from incoming combo ready to do local + // discrepancy check + multiplex = (aAbstractState & EUsbAbstractStateDataMultiplex) + ? ETrue : EFalse; + idle = (aAbstractState & EUsbAbstractStateIdleSetting) + ? ETrue : EFalse; + + // apply any necessary overrides due to incomplete ACM class + // support (this may change the local booleans and also may be + // the reason to inform caller of a failure) + ret = KErrNone; + + if ( multiplex != iAcmDataMultiplex ) + { +#if defined(DISABLE_ACM_CF_DATA_MULTIPLEX) + // if this selector is disabled then the attempt to change the + // bit must fail + ret = KErrNotSupported; + + multiplex = iAcmDataMultiplex; +#endif + } + + if ( idle != iAcmIdleSetting ) + { +#if defined(DISABLE_ACM_CF_IDLE_SETTING) + // if this selector is disabled then the attempt to change the + // bit must fail + ret = KErrNotSupported; + + idle = iAcmIdleSetting; +#endif + } + + // save the new booleans into the private store + iAcmDataMultiplex = multiplex; + iAcmIdleSetting = idle; + + // recreate the private combo from these booleans + newstate = static_cast( + ( iAcmIdleSetting ? EUsbAbstractStateIdleSetting : EUsbAbstractStateNoBits ) + | ( iAcmDataMultiplex ? EUsbAbstractStateDataMultiplex : EUsbAbstractStateNoBits) + ); + + // discrepancy check to see if the client application needs to be + // informed, note that the callback may not have been placed. + if( iAcmState != newstate ) + { + LOGTEXT2(_L8("\tNew Combo [0x%04X]"), newstate); + + if ( iCallback ) + { + // If there was such a function in class + // MHostPushedChangeObserver, notify + // via iCallback->HostAbstractStateChange(newstate); + LOGTEXT(_L8("\tHas No Notification Method in class MHostPushedChangeObserver")); + } + } + + // and save the new state ready for next check + iAcmState = newstate; + + LOGTEXT2(_L8("<>CCdcAcmClass::HandleNewCountryCode aCountryCode=%d"), + aCountryCode); + + TInt ret; + +#if defined(DISABLE_ACM_CF_COUNTRY_SETTING) + + // cite the incoming parameter to suppress 'unreferenced formal parameter' + // warning and then set the return value to show this code does not handle + // the country code. + (void)aCountryCode; + + ret = KErrNotSupported; + +#else + + // check the received code against the array in the descriptor + // and confirm it is one of those present, otherwise return + // 'unknown' : for now, just pretend it always works + iCountryCode = aCountryCode; + + ret = KErrNone; + +#endif + + LOGTEXT2(_L8("<>CCdcAcmClass::HandleSetCommFeature aSelector=%d"), + aSelector); + + // reject any message that has malformed data + if ( aData.Length() != 2 ) + { + LOGTEXT2(_L8("\t***aData.Length (%d) incorrect"), aData.Length()); + LOGTEXT2(_L8("<(&aData[0]); + ppbuffer = &pbuffer; + + newstate = CCdcControlInterface::GetU16(ppbuffer); + + if ( newstate != iAcmState ) + { + ret = HandleNewAbstractState(newstate); + + LOGTEXT4(_L8("\tHandleNewAbstractState=%d [0x%04X]->[0x%04X]"), + ret, iAcmState, newstate); + } + } + break; + + case EUsbCommFeatureSelectCountryCode: + { +#if defined(DISABLE_ACM_CF_COUNTRY_SETTING) + + LOGTEXT(_L8("Country Code Not Supported")); + ret = KErrNotSupported; + +#elif defined(ENABLE_ACM_CF_COUNTRY_SETTING) + + TUint16 newcountry; + + TUint8* pbuffer; + TUint8** ppbuffer; + pbuffer = &aData[0]; + ppbuffer = &pbuffer; + + newcountry = CCdcControlInterface::GetU16(ppbuffer); + + if( newcountry != iCountryCode ) + { + ret = HandleNewCountryCode(newcountry); + + LOGTEXT4(_L8("\tHandleNewCountryCode=%d [0x%04X]->[0x%04X]"), + ret, iCountryCode, newcountry); + } + +#endif + break; + } + + default: + { + LOGTEXT(_L8("\tBad Selector")); + ret = KErrUnknown; + } + } + + LOGTEXT2(_L8("<(iUsbConfig.iStopBits)); + CCdcControlInterface::PutU08(ppbuffer, static_cast(iUsbConfig.iParity )); + CCdcControlInterface::PutU08(ppbuffer, static_cast(iUsbConfig.iDataBits)); + + return KErrNone; + } + +TInt CCdcAcmClass::HandleSetControlLineState(TBool aRtsState, TBool aDtrState) +/** + * Callback for Set Control Line State requests + * + * @param aRtsState RTS state. + * @param aDtrState DTR state. + */ + { + LOGTEXT3(_L8(">>CCdcAcmClass::HandleSetControlLineState aRtsState=%d, " + "aDtrState=%d"), + aRtsState, aDtrState); + + iRtsState = aRtsState; + iDtrState = aDtrState; + if ( iCallback ) + { + iCallback->HostSignalChange(iDtrState,iRtsState); + } + + LOGTEXT(_L8("<BreakRequest(CBreakController::EHost, + CBreakController::EInactive); + } + else if ( aDuration == 0xFFFF ) + { + ret = iBreakController->BreakRequest(CBreakController::EHost, + CBreakController::ELocked); // i.e. locked ON, until further + // notice. + } + else + { + ret = iBreakController->BreakRequest(CBreakController::EHost, + CBreakController::ETiming, + // Convert from host-supplied milliseconds to microseconds. + aDuration*1000); + } + + LOGTEXT2(_L8("\tret = %d"), ret); + return ret; + } + +TInt CCdcAcmClass::SendSerialState(TBool aRing, TBool aDsr, TBool aDcd) +/** + * Send a change in serial state to the host. + * + * Note that Overrun, Parity and Framing errors are not currently supported, + * so are stubbed out with EFalse. + * + * Note that the BREAK signal is managed locally in the break controller + * Active Object. + */ + { + LOGTEXT4(_L8(">>CCdcAcmClass::SendSerialState aRing=%d, " + "aDsr=%d, aDcd=%d"), + aRing, aDsr, aDcd); + + // stub non-supported flags + TBool overrun = EFalse; + TBool parity = EFalse; + TBool framing = EFalse; + + // Save incoming state flags for possible use when notifying break + // changes. + iRingState = aRing; + iDsrState = aDsr; + iDcdState = aDcd; + + // send new state off to the host (this will use an interrupt transfer, + // and will handle all discrepancy checking to suppress same-state + // notifications) + TInt ret = iControl->SendSerialState(overrun, + parity, + framing, + aRing, + BreakActive(), + aDsr, + aDcd); + + LOGTEXT2(_L8("<BreakRequest(aRequester, aState, aDelay); + LOGTEXT2(_L8("\tBreakRequest = %d"), err); + return err; + } + +void CCdcAcmClass::NotifyDataAvailable(MNotifyDataAvailableObserver& aObserver) +/** + * Notify the caller when data is available to be read from the LDD. + * + * @param aObserver The observer to notify completion to. + */ + { + LOGTEXT2(_L8(">>CCdcAcmClass::NotifyDataAvailable aObserver=0x%08x"), &aObserver); + + __ASSERT_DEBUG(iData, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iData->NotifyDataAvailable(aObserver); + + LOGTEXT(_L8("<CancelNotifyDataAvailable(); + } + +// +// End of file diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/CdcControlInterface.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/CdcControlInterface.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,509 @@ +/* +* 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: +* +*/ + +#include +#include +#include +#include +#include "CdcControlInterface.h" +#include "CdcControlInterfaceReader.h" +#include "ClassDescriptor.h" +#include "CdcAcmClass.h" +#include "AcmPanic.h" +#include "AcmUtils.h" +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +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 + */ + { + LOG_STATIC_FUNC_ENTRY + + LOGTEXT2(_L("\tControl Ifc Name = %S"), &aIfcName); + + 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); + + LOGTEXT2(_L8("\tcreated CdcControlInterface iProtocolNum = %d"), iProtocolNum); + } + +TInt CCdcControlInterface::SetUpInterface() +/** + * Set up the interface for use. This involves finding a "Interrupt IN" + * endpoint and, if found, configuring the interface. + */ + { + LOGTEXT(_L8(">>CCdcControlInterface::SetUpInterface")); + + TUsbDeviceCaps dCaps; + TInt ret = iLdd.DeviceCaps(dCaps); + LOGTEXT(_L8("\tchecking result of DeviceCaps")); + if ( ret ) + { + LOGTEXT2(_L8("<(dCaps().iTotalEndpoints); + LOGTEXT2(_L8("\tiTotalEndpoints = %d"), totalEndpoints); + if ( totalEndpoints < KRequiredNumberOfEndpoints ) + { + LOGTEXT2(_L8("<(data), sizeof(data), sizeof(data)); + ret = iLdd.EndpointCaps(dataptr); + LOGTEXT(_L8("\tchecking result of EndpointCaps")); + if ( ret ) + { + LOGTEXT2(_L8("<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; + } + } + LOGTEXT(_L8("\tchecking epFound")); + if ( !epFound ) + { + LOGTEXT2(_L8("< 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( wValue & 0x00ff); + iBuffer[3] = static_cast((wValue & 0xff00) >> 8); + iBuffer[4] = static_cast( wIndex & 0x00ff); + iBuffer[5] = static_cast((wIndex & 0xff00) >> 8); + iBuffer[6] = static_cast( wLength & 0x00ff); + iBuffer[7] = static_cast((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. + */ + { + LOGTEXT2(_L8(">>CCdcControlInterface::SendNetworkConnection aValue=%d"), + aValue); + + // 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((aValue)?0x0001:0x0000); //1 - connected, 0 - disconnected + notification.wIndex = static_cast((aValue)?0x0001:0x0000); + notification.wLength = 0x00; + + TInt ret = WriteData(EEndpoint1, + notification.PackBuffer(), + notification.PackBuffer().Length()); + + LOGTEXT2(_L8("< 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( wValue & 0x00ff); + iBuffer[3] = static_cast((wValue & 0xff00) >> 8); + iBuffer[4] = static_cast( wIndex & 0x00ff); + iBuffer[5] = static_cast((wIndex & 0xff00) >> 8); + iBuffer[6] = static_cast( wLength & 0x00ff); + iBuffer[7] = static_cast((wLength & 0xff00) >> 8); + iBuffer[8] = static_cast( wData & 0x00ff); + iBuffer[9] = static_cast((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. + */ + { + LOG_FUNC + LOGTEXT2(_L8("\taOverRun=%d"), aOverRun); + LOGTEXT2(_L8("\taParity=%d"), aParity); + LOGTEXT2(_L8("\taFraming=%d"), aFraming); + LOGTEXT2(_L8("\taRing=%d"), aRing); + LOGTEXT2(_L8("\taBreak=%d"), aBreak); + LOGTEXT2(_L8("\taTxCarrier=%d"), aTxCarrier); + LOGTEXT2(_L8("\taRxCarrier=%d"), aRxCarrier); + + // 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 + ( + (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 ) + { + LOGTEXT(_L8("\tdata == 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()); + LOGTEXT2(_L8("\tWriteData = %d"), ret); + + return ret; + } + +TInt CCdcControlInterface::WriteData(TEndpointNumber aEndPoint, + TDes8& aDes, + TInt aLength) +/** + * + * + * @param aEndPoint + * @param aDes + * @param aLength + */ + { + LOG_FUNC + LOGTEXT2(_L8("\taEndpoint=%d"), aEndPoint); + + TInt ret; + RTimer timer; + ret = timer.CreateLocal(); + if ( ret ) + { + LOGTEXT2(_L8("\ttimer.CreateLocal = %d- returning"), ret); + return ret; + } + TRequestStatus status; + TRequestStatus timerStatus; + LOGTEXT(_L8("\tAttempting to write data to control interface")); + iLdd.Write(status, aEndPoint, aDes, aLength); + timer.After(timerStatus, KWriteDataTimeout); + User::WaitForRequest(status, timerStatus); + if ( timerStatus != KRequestPending ) + { + // Timeout occurred, silently ignore error condition. + // Assuming that the line has been disconnected + LOGTEXT(_L8("CCdcControlInterface::WriteData() - Timeout occurred")); + iLdd.WriteCancel(aEndPoint); + User::WaitForRequest(status); + ret = timerStatus.Int(); + } + else + { + LOGTEXT(_L8("CCdcControlInterface::WriteData() - Write completed")); + timer.Cancel(); + User::WaitForRequest(timerStatus); + ret = status.Int(); + } + + LOGTEXT2(_L8("\treturning %d"), ret); + return ret; + } + +// +// End of file diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/CdcControlInterfaceReader.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/CdcControlInterfaceReader.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,413 @@ +/* +* 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: +* +*/ + +#include +#include +#include "CdcControlInterfaceReader.h" +#include "AcmPanic.h" +#include "AcmUtils.h" +#include "CdcControlInterfaceRequestHandler.h" +#include "AcmConstants.h" +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +CCdcControlInterfaceReader::CCdcControlInterfaceReader( + MCdcCommsClassRequestHandler& aParent, + RDevUsbcClient& aLdd) +: CActive(KEcacmAOPriority), + iParent(aParent), + iLdd(aLdd) +/** + * Constructor. + * + * @param aParent Observer (ACM port) + * @param aLdd The USB LDD handle to be used. + */ + { + CActiveScheduler::Add(this); + ReadMessageHeader(); + } + +CCdcControlInterfaceReader::~CCdcControlInterfaceReader() +/** + * Destructor + */ + { + LOG_FUNC + + Cancel(); //Call CActive::Cancel() + } + +CCdcControlInterfaceReader* CCdcControlInterfaceReader::NewL( + MCdcCommsClassRequestHandler& aParent, + RDevUsbcClient& aLdd) +/** + * Create a new CCdcControlInterfaceReader object and start reading + * + * @param aParent Observer (ACM port) + * @param aLdd The USB LDD handle to be used. + */ + { + LOG_STATIC_FUNC_ENTRY + + CCdcControlInterfaceReader* self = new(ELeave) CCdcControlInterfaceReader( + aParent, + aLdd); + return self; + } + +void CCdcControlInterfaceReader::RunL() +/** + * This function will be called when a read completes. + */ + { + LOGTEXT2(_L8(">>CCdcControlInterfaceReader::RunL iStatus=%d"), iStatus.Int()); + HandleReadCompletion(iStatus.Int()); + LOGTEXT(_L8("<>CCdcControlInterfaceReader::HandleReadCompletion " + "aError=%d"), aError); + + if ( aError ) + { + ReadMessageHeader(); + LOGTEXT(_L8("<(iLdd.EndpointZeroRequestError()); + ReadMessageHeader(); + return; + } + + LOGTEXT2(_L8("\t- New read! Request 0x%x"), iRequestHeader.iRequest); + + if ( iRequestHeader.IsDataResponseRequired() ) + { + DecodeMessageDataWithResponseRequired(); + } + else if ( iRequestHeader.iLength == 0 ) + { + iMessageData.SetLength(0); + DecodeMessageData(); + } + else + { + ReadMessageData(iRequestHeader.iLength); + } + } + +void CCdcControlInterfaceReader::DecodeMessageDataWithResponseRequired() +/** + * Decode a message which requires data to be sent to the host in response. + */ + { + LOG_FUNC + + LOGTEXT2(_L8("\t- New read! Request 0x%x"), iRequestHeader.iRequest); + TBuf8 returnBuffer; + + switch ( iRequestHeader.iRequest ) + { + case KGetEncapsulated: + { + if ( iParent.HandleGetEncapResponse(returnBuffer) == KErrNone ) + { + // Write Back data here + // At least ack the packet or host will keep sending. If this + // fails, the host will ask again until we do successfully reply. + static_cast(iLdd.SendEp0StatusPacket()); + } + else + { + // Stall bus- unknown message. If this fails, there's nothing we + // can do. + static_cast(iLdd.EndpointZeroRequestError()); + } + } + break; + + case KGetCommFeature: + { + if ( iParent.HandleGetCommFeature(iRequestHeader.iValue, returnBuffer) + == KErrNone ) + { + TRequestStatus status; + iLdd.Write(status, EEndpoint0, + returnBuffer, + returnBuffer.Length(), + EFalse); + User::WaitForRequest(status); + // If this failed, the host will ask again until we do + // successfully reply. + } + else + { + // Stall bus- unknown message. If this fails, there's nothing we + // can do. + static_cast(iLdd.EndpointZeroRequestError()); + } + } + break; + + case KGetLineCoding: + { + if ( iParent.HandleGetLineCoding(returnBuffer) == KErrNone ) + { + TRequestStatus status; + iLdd.Write(status, EEndpoint0, + returnBuffer, + 7, + EFalse); + User::WaitForRequest(status); + } + else + { + // Stall bus- unknown message. If this fails, there's nothing we + // can do. + static_cast(iLdd.EndpointZeroRequestError()); + } + } + break; + + default: + { + LOGTEXT2(_L8("\t- request number not recognised (%d)"), + iRequestHeader.iRequest); + // Stall bus- unknown message. If this fails, there's nothing we can + // do. + static_cast(iLdd.EndpointZeroRequestError()); + } + break; + } + + ReadMessageHeader(); + } + +void CCdcControlInterfaceReader::DecodeMessageData() +/** + * Decode a message that does not require any data to be sent to the host in + * response. In all the requests here, the completion of the class-specific + * function is ack'ed by sending an endpoint zero status packet. The request + * can be nack'ed by signalling an endpoint zero request error. + */ + { + LOG_FUNC + + if ( iMessageData.Length() != iRequestHeader.iLength ) + { + LOGTEXT(_L8("\t- Data length is incorrect")); + ReadMessageHeader(); + return; + } + + LOGTEXT2(_L8("\tNew read! Request %d"), iRequestHeader.iRequest); + + switch ( iRequestHeader.iRequest ) + { + case KSendEncapsulated: + if(iParent.HandleSendEncapCommand(iMessageData) == KErrNone) + { + // If this fails, the host will send again. + static_cast(iLdd.SendEp0StatusPacket()); + } + else + { + // Stall bus- unknown message. If this fails, there's nothing we + // can do. + static_cast(iLdd.EndpointZeroRequestError()); + } + break; + case KSetCommFeature: + if(iParent.HandleSetCommFeature(iRequestHeader.iValue,iMessageData) + == KErrNone) + { + // If this fails, the host will send again. + static_cast(iLdd.SendEp0StatusPacket()); + } + else + { + // Stall bus- unknown message. If this fails, there's nothing we + // can do. + static_cast(iLdd.EndpointZeroRequestError()); + } + break; + case KClearCommFeature: + if(iParent.HandleClearCommFeature(iRequestHeader.iValue) == KErrNone) + { + // If this fails, the host will send again. + static_cast(iLdd.SendEp0StatusPacket()); + } + else + { + // Stall bus- unknown message. If this fails, there's nothing we + // can do. + static_cast(iLdd.EndpointZeroRequestError()); + } + break; + case KSetLineCoding: + if(iParent.HandleSetLineCoding(iMessageData) == KErrNone) + { + // If this fails, the host will send again. + static_cast(iLdd.SendEp0StatusPacket()); + } + else + { + // Stall bus- unknown message. If this fails, there's nothing we + // can do. + static_cast(iLdd.EndpointZeroRequestError()); + } + break; + case KSetControlLineState: + if(iParent.HandleSetControlLineState( + // See CDC spec table 69 (UART state bitmap values)... + (iRequestHeader.iValue & 0x0002) ? ETrue : EFalse, // bTxCarrier + (iRequestHeader.iValue & 0x0001) ? ETrue : EFalse) // bRxCarrier + == KErrNone) + { + // If this fails, the host will send again. + static_cast(iLdd.SendEp0StatusPacket()); + } + else + { + // Stall bus- unknown message. If this fails, there's nothing we + // can do. + static_cast(iLdd.EndpointZeroRequestError()); + } + break; + case KSendBreak: + // The time value sent from the host is in milliseconds. + if(iParent.HandleSendBreak(iRequestHeader.iValue) == KErrNone) + { + // If this fails, the host will send again. + static_cast(iLdd.SendEp0StatusPacket()); + } + else + { + // Stall bus- unknown message. If this fails, there's nothing we + // can do. + static_cast(iLdd.EndpointZeroRequestError()); + } + break; + default: + LOGTEXT2(_L8("\t***request number not recognised (%d)"), + iRequestHeader.iRequest); + // Stall bus- unknown message. If this fails, there's nothing we can + // do. + static_cast(iLdd.EndpointZeroRequestError()); + break; + } + + ReadMessageHeader(); + } + +void CCdcControlInterfaceReader::ReadMessageHeader() +/** + * Post a read request and set the state to indicate that we're waiting for a + * message header. + */ + { + LOG_FUNC + + iState = EWaitingForHeader; + + iLdd.ReadPacket(iStatus, EEndpoint0, iMessageHeader, KUsbRequestHdrSize); + SetActive(); + } + +void CCdcControlInterfaceReader::ReadMessageData(TUint aLength) +/** + * Post a read request and set the state to indicate that we're waiting for + * some message data. + * + * @param aLength Length of data to read. + */ + { + LOG_FUNC + + LOGTEXT2(_L8("\tqueuing read, length = %d"),aLength); + + iState = EWaitingForData; + + iLdd.Read(iStatus, EEndpoint0, iMessageData, static_cast(aLength)); + SetActive(); + } + +// +// End of file diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/CdcDataInterface.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/CdcDataInterface.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,581 @@ +/* +* 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: +* +*/ + +#include +#include "CdcDataInterface.h" +#include "ActiveReader.h" +#include "ActiveWriter.h" +#include "AcmPanic.h" +#include "AcmUtils.h" +#include "ActiveReadOneOrMoreReader.h" +#include "ActiveDataAvailableNotifier.h" +#include "inifile.h" +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +#ifdef __HEADLESS_ACM_TEST_CODE__ +#pragma message ("Building headless ACM (performance test code for RDevUsbcClient)") +#endif // __HEADLESS_ACM_TEST_CODE__ + +CCdcDataInterface::CCdcDataInterface(const TDesC16& aIfcName) +/** + * Overloaded Constructor using interface name. + * @param aIfcName contains the interface name + */ + : CCdcInterfaceBase(aIfcName), + iPacketSize(KDefaultMaxPacketTypeBulk) + { + } + +CCdcDataInterface* CCdcDataInterface::NewL(const TDesC16& aIfcName) +/** + * Create a new CCdcDataInterface object and construct it using interface name + * This call will return an object with a valid USB configuration + * + * @param aParent Observer. + * @param aIfcName Contains the interface name + * @return A pointer to the new object + */ + { + LOG_STATIC_FUNC_ENTRY + + LOGTEXT2(_L("\tData Ifc Name = %S"), &aIfcName); + + CCdcDataInterface* self = new (ELeave) CCdcDataInterface(aIfcName); + CleanupStack::PushL(self); + self->ConstructL(); + CLEANUPSTACK_POP(self); + return self; + } + +void CCdcDataInterface::ConstructL() +/** + * Construct the object + * This call registers the object with the USB device driver + * + * @param aParent Observer. + */ + { + BaseConstructL(); + + iReadOneOrMoreReader = CActiveReadOneOrMoreReader::NewL(*this, iLdd, EEndpoint2); + iReader = CActiveReader::NewL(*this, iLdd, EEndpoint2); + iDataAvailableNotifier = CActiveDataAvailableNotifier::NewL(*this, iLdd, EEndpoint2); + iWriter = CActiveWriter::NewL(*this, iLdd, EEndpoint1); + iLinkState = CLinkStateNotifier::NewL(*this, iLdd); + + iLinkState->Start(); + + LOGTEXT(_L8("\tchecking ecacm.ini")); + iHostCanHandleZLPs = EFalse; + GetHostZLPHandlingFromFile(); + LOGTEXT(_L8("\tfinished checking ecacm.ini")); + } + +TInt CCdcDataInterface::SetUpInterface() +/** + * Retrieves the device capabilities and searches for suitable input and + * output bulk endpoints. If suitable endpoints are found, an interface + * descriptor for the endpoints is registered with the LDD. + */ + { + LOGTEXT(_L8(">>CCdcDataInterface::SetUpInterface")); + + TUsbDeviceCaps dCaps; + TInt ret = iLdd.DeviceCaps(dCaps); + LOGTEXT(_L8("\tchecking result of DeviceCaps")); + if ( ret ) + { + LOGTEXT2(_L8("<(dCaps().iTotalEndpoints); + LOGTEXT2(_L8("\tiTotalEndpoints = %d"), totalEndpoints); + if ( totalEndpoints < KRequiredNumberOfEndpoints ) + { + LOGTEXT2(_L8("<(data), sizeof(data), sizeof(data)); + ret = iLdd.EndpointCaps(dataptr); + LOGTEXT(_L8("\tchecking result of EndpointCaps")); + if ( ret ) + { + LOGTEXT2(_L8("<MaxPacketSize() ); + + const TUint KBulkInFlags = KUsbEpTypeBulk | KUsbEpDirIn; + const TUint KBulkOutFlags = KUsbEpTypeBulk | KUsbEpDirOut; + + // use EEndPoint1 for TX (IN) EEndpoint1 + if (! foundIn && (caps->iTypesAndDir & KBulkInFlags) == KBulkInFlags) + { + + ifc().iEndpointData[0].iType = KUsbEpTypeBulk; + 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 Bulk at 64 + ifc().iEndpointData[0].iSize = maxSize; + foundIn = ETrue; + } + // use EEndPoint2 for RX (OUT) endpoint + else if ( !foundOut + && (caps->iTypesAndDir & KBulkOutFlags) == KBulkOutFlags + ) + { + // EEndpoint2 is going to be our RX (OUT, read) endpoint + ifc().iEndpointData[1].iType = KUsbEpTypeBulk; + ifc().iEndpointData[1].iDir = KUsbEpDirOut; + + //get the max packet size it can potentially support + //it's possible that it can support Isoch (1023) which is greater + //than max for Bulk at 64 + ifc().iEndpointData[1].iSize = maxSize; + foundOut = ETrue; + } + } + + if (! (foundIn && foundOut)) + { + LOGTEXT2(_L8("<Write(aDes, aLen, requestZlp); + } + else + { + iWriter->Write(aDes, aLen, EFalse); + } + + LOGTEXT(_L8("<>CCdcDataInterface::WriteCompleted aError=%d"), aError); + +#ifdef __HEADLESS_ACM_TEST_CODE__ + // Issue another Read or ReadOneOrMore as appropriate. + // If the Write completed with an error, we panic, as it's invalidating + // the test. + __ASSERT_DEBUG(aError == KErrNone, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + switch ( iHeadlessReadType ) + { + case ERead: + LOGTEXT2(_L8("__HEADLESS_ACM_TEST_CODE__- issuing Read for %d bytes"), + iHeadlessReadLength); + __ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iReader->Read(iHeadlessAcmBuffer, iHeadlessReadLength); + break; + case EReadOneOrMore: + LOGTEXT2(_L8("__HEADLESS_ACM_TEST_CODE__- issuing ReadOneOrMore for %d bytes"), + iHeadlessReadLength); + __ASSERT_DEBUG(iReadOneOrMoreReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iReadOneOrMoreReader->ReadOneOrMore(iHeadlessAcmBuffer, iHeadlessReadLength); + break; + case EUnknown: + default: + _USB_PANIC(KAcmPanicCat, EPanicInternalError); + break; + } +#else + // In case the write observer wants to post another write synchronously on + // being informed that this write has completed, use this little 'temp' + // fiddle. + __ASSERT_DEBUG(iWriteObserver, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + MWriteObserver* temp = iWriteObserver; + iWriteObserver = NULL; + LOGTEXT(_L8("\tcalling WriteCompleted on observer")); + temp->WriteCompleted(aError); +#endif // __HEADLESS_ACM_TEST_CODE__ + + LOGTEXT(_L8("<Cancel(); + + iWriteObserver = NULL; + } + +void CCdcDataInterface::Read(MReadObserver& aObserver, + TDes8& aDes, + TInt aMaxLen) +/** + * Read data from the interface. As the LDD supports an appropriate function, + * this request can be passed straight down. + * + * @param aObserver The observer to notify of completion. + * @param aDes Descriptor to put the read data in + * @param aMaxLen Number of bytes to read + */ + { + LOG_FUNC + +#ifdef __HEADLESS_ACM_TEST_CODE__ + LOGTEXT(_L8("__HEADLESS_ACM_TEST_CODE__")); + // Issue a Read using our special internal buffer. + iHeadlessReadType = ERead; + iHeadlessReadLength = aMaxLen; + static_cast(&aObserver); + static_cast(&aDes); + __ASSERT_DEBUG(aMaxLen <= iHeadlessAcmBuffer.MaxLength(), + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + __ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iReader->Read(iHeadlessAcmBuffer, aMaxLen); +#else + __ASSERT_DEBUG(!iReadObserver, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iReadObserver = &aObserver; + + __ASSERT_DEBUG(iReader, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iReader->Read(aDes, aMaxLen); +#endif // __HEADLESS_ACM_TEST_CODE__ + } + +void CCdcDataInterface::ReadOneOrMore(MReadOneOrMoreObserver& aObserver, + TDes8& aDes, + TInt aMaxLen) +/** + * Read a given amount of data from the interface, but complete if any data + * arrives. + * + * @param aObserver The observer to notify of completion. + * @param aDes Descriptor to put the read data in + * @param aMaxLen Number of bytes to read + */ + { + LOG_FUNC + +#ifdef __HEADLESS_ACM_TEST_CODE__ + LOGTEXT(_L8("__HEADLESS_ACM_TEST_CODE__")); + // Issue a ReadOneOrMore using our special internal buffer. + iHeadlessReadType = EReadOneOrMore; + iHeadlessReadLength = aMaxLen; + static_cast(&aObserver); + static_cast(&aDes); + __ASSERT_DEBUG(aMaxLen <= iHeadlessAcmBuffer.MaxLength(), + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + __ASSERT_DEBUG(iReadOneOrMoreReader, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iReadOneOrMoreReader->ReadOneOrMore(iHeadlessAcmBuffer, aMaxLen); +#else + __ASSERT_DEBUG(!iReadOneOrMoreObserver, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iReadOneOrMoreObserver = &aObserver; + + __ASSERT_DEBUG(iReadOneOrMoreReader, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iReadOneOrMoreReader->ReadOneOrMore(aDes, aMaxLen); +#endif // __HEADLESS_ACM_TEST_CODE__ + } + +void CCdcDataInterface::ReadOneOrMoreCompleted(TInt aError) +/** + * The completion function, called when a ReadOneOrMore request is completed + * by the LDD. + * + * @param aError The result of the read request. + */ + { + LOGTEXT2(_L8(">>CCdcDataInterface::ReadOneOrMoreCompleted aError=%d"), + aError); + +#ifdef __HEADLESS_ACM_TEST_CODE__ + LOGTEXT2(_L8("__HEADLESS_ACM_TEST_CODE__- issuing Write for %d bytes"), + iHeadlessAcmBuffer.Length()); + // Write back the data just read. + // If the ReadOneOrMore completed with an error, we panic, as it's + // invalidating the test. + __ASSERT_DEBUG(aError == KErrNone, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + __ASSERT_DEBUG(iWriter, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iWriter->Write(iHeadlessAcmBuffer, iHeadlessAcmBuffer.Length(), EFalse); +#else + __ASSERT_DEBUG(iReadOneOrMoreObserver, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + // See comment in WriteCompleted. + MReadOneOrMoreObserver* temp = iReadOneOrMoreObserver; + iReadOneOrMoreObserver = NULL; + LOGTEXT(_L8("\tcalling ReadOneOrMoreCompleted on observer")); + temp->ReadOneOrMoreCompleted(aError); +#endif // __HEADLESS_ACM_TEST_CODE__ + + LOGTEXT(_L8("<>CCdcDataInterface::ReadCompleted aError=%d"), aError); + +#ifdef __HEADLESS_ACM_TEST_CODE__ + LOGTEXT2(_L8("__HEADLESS_ACM_TEST_CODE__- issuing Write for %d bytes"), + iHeadlessAcmBuffer.Length()); + // Write back the data just read. + // If the Read completed with an error, we panic, as it's invalidating the + // test. + __ASSERT_DEBUG(aError == KErrNone, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + __ASSERT_DEBUG(iWriter, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + iWriter->Write(iHeadlessAcmBuffer, iHeadlessAcmBuffer.Length(), EFalse); +#else + __ASSERT_DEBUG(iReadObserver, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + // See comment in WriteCompleted. + MReadObserver* temp = iReadObserver; + iReadObserver = NULL; + LOGTEXT(_L8("\tcalled ReadCompleted on observer")); + temp->ReadCompleted(aError); +#endif // __HEADLESS_ACM_TEST_CODE__ + + LOGTEXT(_L8("<Cancel(); + iReadOneOrMoreReader->Cancel(); + iReadObserver = NULL; + iReadOneOrMoreObserver = NULL; + } + + +void CCdcDataInterface::GetHostZLPHandlingFromFile() +/** + * Opens the ECACM.ini file to check on the capabilities of the host device. + * If the ini file cannot be found or read successfully, the default setting i.e. the + * host device CANNOT handle Zero Length Packets (set in CCdcAcmClass::ConstructL()), + * is kept. + */ + { + LOG_FUNC + + CIniFile* iniFile = NULL; + + _LIT(KEcacmIniFilename, "ecacm.ini" ); + _LIT(KEcacmIniFilePath, "\\system\\data\\" ); + + TRAPD(error, iniFile = CIniFile::NewL(KEcacmIniFilename, KEcacmIniFilePath)); + + if (error == KErrNone) + { + TInt hostHandlesZLPs = 1; + + _LIT(KHostUSBDeviceDriver, "HostUSBDeviceDriver"); + _LIT(KCanHandleZLP, "CanHandleZLP"); + + if ( iniFile->FindVar(KHostUSBDeviceDriver, KCanHandleZLP(), hostHandlesZLPs)) + { + iHostCanHandleZLPs = (( hostHandlesZLPs == 1 ) ? ETrue : EFalse ); + + LOGTEXT2(_L8("\tecacm.ini: CanHandleZLP=%d"), hostHandlesZLPs); + } + + delete iniFile; + } + } + +void CCdcDataInterface::NotifyDataAvailableCompleted(TInt aError) +/** + * Called by the active data available notifier object when it completes. + * + * @param aError Error. + */ + { + LOGTEXT2(_L8(">>CCdcDataInterface::NotifyDataAvailableCompleted aError=%d"), aError); + + // See comment in WriteCompleted. + MNotifyDataAvailableObserver* temp = iNotifyDataAvailableObserver; + iNotifyDataAvailableObserver = NULL; + LOGTEXT(_L8("\tcalled NotifyDataAvailableCompleted on observer")); + temp->NotifyDataAvailableCompleted(aError); + + LOGTEXT(_L8("<NotifyDataAvailable(); + } + +void CCdcDataInterface::CancelNotifyDataAvailable() +/** + * Cancel notification of arrival of data. + */ + { + LOG_FUNC + + __ASSERT_DEBUG(iDataAvailableNotifier, _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + iDataAvailableNotifier->Cancel(); + iNotifyDataAvailableObserver = NULL; + } + +// +// End of file diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/CdcInterfaceBase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/CdcInterfaceBase.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,139 @@ +/* +* 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: +* +*/ + +#include +#include "CdcInterfaceBase.h" +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +CCdcInterfaceBase::CCdcInterfaceBase(const TDesC16& aIfcName) +/** + * Constructor. + * + * @param aIfcName The name of the interface. + */ + { + iIfcName.Set(aIfcName); + } + +void CCdcInterfaceBase::BaseConstructL() +/** + * Construct the object + * This call registers the object with the USB device driver + */ + { + LOGTEXT(_L8("\tcalling RDevUsbcClient::Open")); + // 0 is assumed to mean ep0 + TInt ret = iLdd.Open(0); + if ( ret ) + { + LOGTEXT2(_L8("\tRDevUsbcClient::Open = %d"), ret); + LEAVEIFERRORL(ret); + } + + ret = SetUpInterface(); + if ( ret ) + { + LOGTEXT2(_L8("\tSetUpInterface = %d"), ret); + LEAVEIFERRORL(ret); + } + } + +CCdcInterfaceBase::~CCdcInterfaceBase() +/** + * Destructor. + */ + { + LOG_FUNC + + if ( iLdd.Handle() ) + { + LOGTEXT(_L8("\tLDD handle exists")); + + // Don't bother calling ReleaseInterface- the base driver spec says + // that Close does it for us. + + LOGTEXT(_L8("\tclosing LDD session")); + iLdd.Close(); + } + } + +TInt CCdcInterfaceBase::GetInterfaceNumber(TUint8& aIntNumber) +/** + * Get my interface number + * + * @param aIntNumber My interface number + * @return Error. + */ + { + LOG_FUNC + + TInt interfaceSize = 0; + + // 0 means the main interface in the LDD API + TInt res = iLdd.GetInterfaceDescriptorSize(0, interfaceSize); + + if ( res ) + { + LOGTEXT2(_L8("\t***GetInterfaceDescriptorSize()=%d"), res); + return res; + } + + HBufC8* interfaceBuf = HBufC8::New(interfaceSize); + if ( !interfaceBuf ) + { + LOGTEXT(_L8("\t***failed to create interfaceBuf- " + "returning KErrNoMemory")); + return KErrNoMemory; + } + + TPtr8 interfacePtr = interfaceBuf->Des(); + interfacePtr.SetLength(0); + // 0 means the main interface in the LDD API + res = iLdd.GetInterfaceDescriptor(0, interfacePtr); + + if ( res ) + { + delete interfaceBuf; + LOGTEXT2(_L8("\t***GetInterfaceDescriptor()=%d"), res); + return res; + } + +#ifdef __FLOG_ACTIVE + LOGTEXT2(_L8("\t***interface length = %d"), interfacePtr.Length()); + for ( TInt i = 0 ; i < interfacePtr.Length() ; i++ ) + { + LOGTEXT2(_L8("\t***** %x"),interfacePtr[i]); + } +#endif + + const TUint8* buffer = reinterpret_cast(interfacePtr.Ptr()); + // 2 is where the interface number is, according to the LDD API + aIntNumber = buffer[2]; + + LOGTEXT2(_L8("\tinterface number = %d"), aIntNumber); + + delete interfaceBuf; + + return KErrNone; + } + +// +// End of file diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/ClassDescriptor.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/ClassDescriptor.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,81 @@ +/* +* 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: +* +*/ + +#include "ClassDescriptor.h" +#include "AcmPanic.h" +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +TDes8& TUsbCsClassDescriptor::Des() +/** + * This function packs the TUsbCsClassDescriptor class into a descriptor with + * the correct byte alignment for transmission on the USB bus. + * + * @return Correctly-aligned buffer. NB The buffer returned is a member of + * this class and has the same lifetime. + */ + { + TUint index = 0; + + iBuffer.SetLength(KUsbClassSpecificBufferSize); + + iBuffer[index++] = iHdrSize; + iBuffer[index++] = iHdrType; + iBuffer[index++] = iHdrSubType; + iBuffer[index++] = (TUint8) ( iHdrBcdCDC & 0x00ff); + iBuffer[index++] = (TUint8) ((iHdrBcdCDC & 0xff00) >> 8); + iBuffer[index++] = iAcmSize; + iBuffer[index++] = iAcmType; + iBuffer[index++] = iAcmSubType; + iBuffer[index++] = iAcmCapabilities; + iBuffer[index++] = iUnSize; + iBuffer[index++] = iUnType; + iBuffer[index++] = iUnSubType; + iBuffer[index++] = iUnMasterInterface; + iBuffer[index++] = iUnSlaveInterface; + +#if defined(DISABLE_ACM_CF_COUNTRY_SETTING) + + // no functional descriptor needed + +#elif defined(ENABLE_ACM_CF_COUNTRY_SETTING) + + // CDC Country Selection Functional Descriptor + iBuffer[index++] = iCsSize; + iBuffer[index++] = iCsType; + iBuffer[index++] = iCsSubType; + iBuffer[index++] = iCsRelDate; + + for ( TUint scan = 0 ; scan < KUsbCommNumCountries ; scan++ ) + { + iBuffer[index++] = (TUint8) (iCsCountryCode[scan] & 0x00ff); + iBuffer[index++] = (TUint8) ((iCsCountryCode[scan] & 0xff00) >> 8); + } + +#endif + + __ASSERT_DEBUG(index == KUsbClassSpecificBufferSize, + _USB_PANIC(KAcmPanicCat, EPanicInternalError)); + + return iBuffer; + } + +// +// End of file diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/DllMain.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/DllMain.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,33 @@ +/* +* 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: +* +*/ + +#include +#include +#include "AcmPortFactory.h" + +extern "C" IMPORT_C CSerial* LibEntryL(void); + +EXPORT_C CSerial* LibEntryL() +/** + * Lib main entry point + */ + { + return (CAcmPortFactory::NewL()); + } + +// +// End of file diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/RegistrationPort.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/RegistrationPort.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,513 @@ +/* +* 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: +* +*/ + +#include "RegistrationPort.h" +#include "AcmConstants.h" +#include "AcmUtils.h" +#include +#include "acmcontroller.h" +#include +#include "acmserverconsts.h" + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +CRegistrationPort* CRegistrationPort::NewL(MAcmController& aAcmController, + TUint aUnit) +/** + * Factory function. + * + * @param aOwner Observer (the port factory). + * @param aUnit The port number. + * @return Ownership of a newly created CRegistrationPort object + */ + { + LOG_STATIC_FUNC_ENTRY + + CRegistrationPort* self = new(ELeave) CRegistrationPort(aAcmController); + CleanupClosePushL(*self); + self->ConstructL(aUnit); + CleanupStack::Pop(); + return self; + } + +void CRegistrationPort::ConstructL(TUint aUnit) +/** + * 2nd-phase constructor. + * + * @param aUnit The port number. + */ + { + LOG_FUNC + + TName name; + name.Num(aUnit); + LEAVEIFERRORL(SetName(&name)); + } + +CRegistrationPort::CRegistrationPort(MAcmController& aAcmController) +/** + * Constructor. + * + * @param aAcmController To use when creating and destroying ACM functions. + */ + : iAcmController(aAcmController) + { + } + +void CRegistrationPort::StartRead(const TAny* /*aClientBuffer*/, + TInt /*aLength*/) +/** + * Queue a read + * + * @param aClientBuffer pointer to the Client's buffer + * @param aLength number of bytes to read + */ + { + LOG_FUNC + + ReadCompleted(KErrNotSupported); + } + +void CRegistrationPort::ReadCancel() +/** + * Cancel a read + */ + { + LOG_FUNC + + ReadCompleted(KErrNotSupported); + } + + +TInt CRegistrationPort::QueryReceiveBuffer(TInt& /*aLength*/) const +/** + * Get the size of the receive buffer + * + * @param aLength reference to where the size will be written to + * @return KErrNotSupported always. + */ + { + LOG_FUNC + + return KErrNotSupported; + } + +void CRegistrationPort::ResetBuffers(TUint) +/** + * Reset Tx and Rx buffers. + * Not supported. + */ + { + LOG_FUNC + } + +void CRegistrationPort::StartWrite(const TAny* /*aClientBuffer*/, + TInt /*aLength*/) +/** + * Queue a write + * + * @param aClientBuffer pointer to the Client's buffer + * @param aLength number of bytes to write + */ + { + LOG_FUNC + + WriteCompleted(KErrNotSupported); + } + +void CRegistrationPort::WriteCancel() +/** + * Cancel a pending write + */ + { + LOG_FUNC + + WriteCompleted(KErrNotSupported); + } + +void CRegistrationPort::Break(TInt /*aTime*/) +/** + * Send a break signal to the host. + * + * @param aTime Length of break in microseconds + */ + { + LOG_FUNC + + BreakCompleted(KErrNotSupported); + } + +void CRegistrationPort::BreakCancel() +/** + * Cancel a pending break. + */ + { + LOG_FUNC + } + +TInt CRegistrationPort::GetConfig(TDes8& /*aDes*/) const +/** + * Pass a config request + * + * @param aDes config will be written to this descriptor + * @return Error + */ + { + LOG_FUNC + + return KErrNotSupported; + } + +TInt CRegistrationPort::SetConfig(const TDesC8& /*aDes*/) +/** + * Set up the comm port. + * + * @param aDes descriptor containing the new config + * @return Error + */ + { + LOG_FUNC + + return KErrNotSupported; + } + +TInt CRegistrationPort::SetServerConfig(const TDesC8& /*aDes*/) +/** + * Set the server config. + * + * @param aDes package with new server configurations + * @return Error + */ + { + LOG_FUNC + + return KErrNotSupported; + } + +TInt CRegistrationPort::GetServerConfig(TDes8& /*aDes*/) +/** + * Get the server configs + * + * @param aDes server configs will be written to this descriptor + * @return Error + */ + { + LOG_FUNC + + return KErrNotSupported; + } + +TInt CRegistrationPort::GetCaps(TDes8& /*aDes*/) +/** + * Read capabilities from the driver + * + * @param aDes caps will be written to this descriptor + * @return Error + */ + { + LOG_FUNC + + return KErrNotSupported; + } + +TInt CRegistrationPort::GetSignals(TUint& /*aSignals*/) +/** + * Get the status of the signal pins + * + * @param aSignals signals will be written to this descriptor + * @return Error + */ + { + LOG_FUNC + + return KErrNotSupported; + } + +TInt CRegistrationPort::SetSignalsToMark(TUint aAcmField) +/** + * Set selected signals to high (logical 1). + * + * Used in the registration port as an API to create aNoAcms ACM interfaces. + * This method of creating interfaces is deprecated, use the ACM Server instead. + * + * @param aAcmField Low 2 bytes- number of ACM interfaces to create. High 2 + * bytes- protocol number (from USBCDC 1.1 Table 17). + * @return Error + */ + { + LOGTEXT2(_L8(">>CRegistrationPort::SetSignalsToMark aAcmField = 0x%x"), aAcmField); + + // Extract number of interfaces and protocol number + // low 2 bytes represent the number of ACMs + // high 2 bytes represent the protocol number to use + TUint interfaces = aAcmField & 0x0000FFFF; + TUint8 protocolNumber = (aAcmField & 0xFFFF0000) >> 16; + + // If there is no protocol number, assume the default + // i.e. the client is not using this interface to set the protocol number + // NOTE: This means you cannot set a protocol number of 0 - to do this use the ACM Server. + protocolNumber = protocolNumber ? protocolNumber : KDefaultAcmProtocolNum; + + TInt ret = iAcmController.CreateFunctions(interfaces, protocolNumber, KControlIfcName, KDataIfcName); + + LOGTEXT2(_L8("<>CRegistrationPort::SetSignalsToSpace aNoAcms = %d"), aNoAcms); + + iAcmController.DestroyFunctions(aNoAcms); + + LOGTEXT(_L8("<(iValue & 0x00ff); + iBuffer[3] = static_cast((iValue & 0xff00) >> 8); + iBuffer[4] = static_cast(iIndex & 0x00ff); + iBuffer[5] = static_cast((iIndex & 0xff00) >> 8); + iBuffer[6] = static_cast(iLength & 0x00ff); + iBuffer[7] = static_cast((iLength & 0xff00) >> 8); + + return iBuffer; + } + +TInt TUsbRequestHdr::Decode(const TDesC8& aBuffer, TUsbRequestHdr& aTarget) +/** + * This function unpacks into the TUsbRequestHdr class from a descriptor with + * the alignment that would be introduced on the USB bus. + * + * @param aBuffer Input buffer + * @param aTarget Unpacked header. + * @return Error. + */ + { + if (aBuffer.Length() < static_cast(KUsbRequestHdrSize)) + return KErrGeneral; + + aTarget.iRequestType = aBuffer[0]; + aTarget.iRequest = aBuffer[1]; + aTarget.iValue = static_cast(aBuffer[2] + (aBuffer[3] << 8)); + aTarget.iIndex = static_cast(aBuffer[4] + (aBuffer[5] << 8)); + aTarget.iLength = static_cast(aBuffer[6] + (aBuffer[7] << 8)); + return KErrNone; + } + +TBool TUsbRequestHdr::IsDataResponseRequired() const +/** + * This function determines whether data is required by the host in response + * to a message header. + * @return TBool Flag indicating whether a data response required. + */ + { + return (iRequestType & 0x80) ? ETrue : EFalse; + } + +// +// End of file diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/acmserver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/acmserver.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,87 @@ +/* +* Copyright (c) 2007-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: +* ACM server. +* +*/ + +/** + @file + @internalComponent +*/ + +#include +#include "acmserver.h" +#include "acmsession.h" +#include "acmserversecuritypolicy.h" +#include "acmserverconsts.h" + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +CAcmServer* CAcmServer::NewL(MAcmController& aAcmController) + { + LOG_STATIC_FUNC_ENTRY + + CAcmServer* self = new(ELeave) CAcmServer(aAcmController); + CleanupStack::PushL(self); + TInt err = self->Start(KAcmServerName); + // KErrAlreadyExists is a success case (c.f. transient server boilerplate + // code). + if ( err != KErrAlreadyExists ) + { + LEAVEIFERRORL(err); + } + CleanupStack::Pop(self); + return self; + } + +CAcmServer::~CAcmServer() + { + LOG_FUNC + } + +CAcmServer::CAcmServer(MAcmController& aAcmController) + : CPolicyServer(CActive::EPriorityStandard, KAcmServerPolicy), + iAcmController(aAcmController) + { + } + +CSession2* CAcmServer::NewSessionL(const TVersion& aVersion, const RMessage2& aMessage) const + { + LOG_FUNC + + //Validate session as coming from UsbSvr + static _LIT_SECURITY_POLICY_S0(KSidPolicy, 0x101fe1db); + TBool auth = KSidPolicy.CheckPolicy(aMessage); + if(!auth) + { + LEAVEIFERRORL(KErrPermissionDenied); + } + + // Version number check... + TVersion v( KAcmSrvMajorVersionNumber, + KAcmSrvMinorVersionNumber, + KAcmSrvBuildNumber); + + if ( !User::QueryVersionSupported(v, aVersion) ) + { + LEAVEIFERRORL(KErrNotSupported); + } + + CAcmSession* sess = CAcmSession::NewL(iAcmController); + LOGTEXT2(_L8("\tsess = 0x%08x"), sess); + return sess; + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/acmsession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/acmsession.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,102 @@ +/* +* Copyright (c) 2005-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: +* ACM session. +* +*/ + +/** + @file + @internalComponent +*/ + +#include "acmserverconsts.h" +#include "acmsession.h" +#include "AcmPortFactory.h" +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +CAcmSession* CAcmSession::NewL(MAcmController& aAcmController) + { + LOG_STATIC_FUNC_ENTRY + + CAcmSession* self = new(ELeave) CAcmSession(aAcmController); + return self; + } + +CAcmSession::CAcmSession(MAcmController& aAcmController) + : iAcmController(aAcmController) + { + LOG_FUNC + } + +CAcmSession::~CAcmSession() + { + LOG_FUNC + } + +void CAcmSession::CreateFunctionsL(const RMessage2& aMessage) + { + LOG_FUNC + + RBuf acmControlIfcName, acmDataIfcName; + + TInt size = aMessage.GetDesLengthL(2); + acmControlIfcName.CreateL(size); + acmControlIfcName.CleanupClosePushL(); + aMessage.ReadL(2, acmControlIfcName); + + size = aMessage.GetDesLengthL(3); + acmDataIfcName.CreateL(size); + acmDataIfcName.CleanupClosePushL(); + aMessage.ReadL(3, acmDataIfcName); + + LOGTEXT5(_L("\taNoAcms = %d, aProtocolNum = %d, Control Ifc Name = %S, Data Ifc Name = %S"), + aMessage.Int0(), aMessage.Int1(), &acmControlIfcName, &acmDataIfcName); + + LEAVEIFERRORL(iAcmController.CreateFunctions(aMessage.Int0(), aMessage.Int1(), acmControlIfcName, acmDataIfcName)); + + CleanupStack::PopAndDestroy(2); + } + +void CAcmSession::ServiceL(const RMessage2& aMessage) + { + LOG_FUNC + LOGTEXT2(_L8("\taMessage.Function() = %d"), aMessage.Function()); + + switch ( aMessage.Function() ) + { + case EAcmCreateAcmFunctions: + { + TRAPD (err, CreateFunctionsL(aMessage)); + aMessage.Complete(err); + break; + } + + case EAcmDestroyAcmFunctions: + { + iAcmController.DestroyFunctions(aMessage.Int0()); + aMessage.Complete(KErrNone); + break; + } + + default: + // Unknown function, panic the user + aMessage.Panic(KAcmSrvPanic, EAcmBadAcmMessage); + break; + } + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/linkstatenotifier.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/acm/classimplementation/ecacm/src/linkstatenotifier.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,160 @@ +/* +* Copyright (c) 2006-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 +#include +#include +#include "AcmPanic.h" +#include "linkstatenotifier.h" + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "ECACM"); +#endif + +CLinkStateNotifier* CLinkStateNotifier::NewL(MLinkStateObserver& aParent, RDevUsbcClient& aUsb) + { + LOG_STATIC_FUNC_ENTRY + + CLinkStateNotifier* self = new (ELeave) CLinkStateNotifier(aParent, aUsb); + return self; + } + + +CLinkStateNotifier::CLinkStateNotifier(MLinkStateObserver& aParent, RDevUsbcClient& aUsb) + : CActive(EPriorityStandard), + iParent(aParent), iUsb(aUsb) + { + LOG_FUNC + + CActiveScheduler::Add(this); + } + + + +/** +CObexUsbHandler destructor. +*/ +CLinkStateNotifier::~CLinkStateNotifier() + { + LOG_FUNC + Cancel(); + } + + +/** +Standard active object error function. + +@return KErrNone because currently nothing should cause this to be called. +*/ +TInt CLinkStateNotifier::RunError(TInt /*aError*/) + { + return KErrNone; + } + + +/** +This function will be called upon a change in the state of the device +(as set up in AcceptL). +*/ +void CLinkStateNotifier::RunL() + { + LOGTEXT2(_L8("CObexUsbHandler::RunL called state=0x%X"), iUsbState); + + if (iStatus != KErrNone) + { + LOGTEXT2(_L8("CObexUsbHandler::RunL() - Error = %d"),iStatus.Int()); + LinkDown(); + iParent.MLSOStateChange(KDefaultMaxPacketTypeBulk); + + return; + } + + if (!(iUsbState & KUsbAlternateSetting)) + { + TUsbcDeviceState deviceState = static_cast(iUsbState); + + switch(deviceState) + { + case EUsbcDeviceStateUndefined: + LinkDown(); + break; + + case EUsbcDeviceStateAttached: + case EUsbcDeviceStatePowered: + case EUsbcDeviceStateDefault: + case EUsbcDeviceStateAddress: + case EUsbcDeviceStateSuspended: + break; + + case EUsbcDeviceStateConfigured: + LinkUp(); + break; + + default: + __ASSERT_DEBUG(false, _USB_PANIC(KAcmPanicCat, EPanicUnknownDeviceState)); + break; + } + } + + iParent.MLSOStateChange(iPacketSize || KDefaultMaxPacketTypeBulk); + + // Await further notification of a state change. + iUsb.AlternateDeviceStatusNotify(iStatus, iUsbState); + SetActive(); + } + + +/** +Standard active object cancellation function. +*/ +void CLinkStateNotifier::DoCancel() + { + LOG_FUNC + + iUsb.AlternateDeviceStatusNotifyCancel(); + } + + + +/** +Accept an incoming connection. +*/ +void CLinkStateNotifier::Start() + { + LOG_FUNC + iUsb.AlternateDeviceStatusNotify(iStatus, iUsbState); + SetActive(); + } + + +void CLinkStateNotifier::LinkUp() + { + if (iUsb.CurrentlyUsingHighSpeed()) + { + iPacketSize = KMaxPacketTypeBulkHS; + } + else + { + iPacketSize = KMaxPacketTypeBulkFS; + } + } + + +void CLinkStateNotifier::LinkDown() + { + iPacketSize = 0; + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/bld.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,22 @@ +/* +* Copyright (c) 2007-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 "acm/bld.inf" +#include "ms/bld.inf" +#include "obex/bld.inf" +#include "whcm/bld.inf" + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/ms/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/ms/bld.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,18 @@ +/* +* Copyright (c) 2007-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 "classcontroller/group/bld.inf" diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/group/BLD.INF --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/group/BLD.INF Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,22 @@ +/* +* Copyright (c) 2004-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: +* +*/ + +PRJ_MMPFILES + +#if !(defined(WINS) || defined(WINSCW)) +msclasscontroller.mmp // Mass Storage Class Controller plugin +#endif diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/group/msclasscontroller.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/group/msclasscontroller.mmp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,55 @@ +/* +* Copyright (c) 2004-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: +* usbmassstorageclient.dll USB mass storage server client side API +* +*/ + +/** + @file +*/ + +target msclasscontroller.dll //Recommended unpaged +CAPABILITY CommDD NetworkControl NetworkServices LocalServices ProtServ +targettype plugin + + +uid 0x10009d8d 0x10204bbb + + +userinclude ../inc + +OS_LAYER_SYSTEMINCLUDE_SYMBIAN + +sourcepath ../src +source CUsbMsClassController.cpp +source CUsbMsClassImpCollection.cpp + +start resource usbms.rss +targetpath /private/10204bbb +header +end + +start resource 10204bbb.rss +target msclasscontroller.rsc +end + +library euser.lib +LIBRARY usbclasscontroller.lib +LIBRARY efsrv.lib +LIBRARY bafl.lib + +#include + +VENDORID 0x70000001 diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/inc/CUsbMsClassController.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/inc/CUsbMsClassController.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,84 @@ +/* +* Copyright (c) 2004-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: +* Adheres to the UsbMan USB Class API and talks to mass storage file system +* +*/ + +/** + @file + @internalTechnology +*/ + +#ifndef __CUSBMSCLASSCONTROLLER_H__ +#define __CUSBMSCLASSCONTROLLER_H__ + +#include +#include +#include + +_LIT(KUsbMsResource, "z:\\private\\101fe1db\\usbms.rsc"); + +class MUsbClassControllerNotify; + +const TInt KMsStartupPriority = 3; + + +/** + The CUsbMsClassController class + + Implements the USB Class Controller API + */ +NONSHARABLE_CLASS(CUsbMsClassController) : public CUsbClassControllerPlugIn + { + +public: + static CUsbMsClassController* NewL(MUsbClassControllerNotify& aOwner); + ~CUsbMsClassController(); + +private: + // Functions derived from CActive. + virtual void RunL(); + virtual void DoCancel(); + virtual TInt RunError(TInt aError); + +private: + // Functions derived from CUsbClassControllerBase + virtual void Start(TRequestStatus& aStatus); + virtual void Stop(TRequestStatus& aStatus); + + virtual void GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const; + +private: + CUsbMsClassController(MUsbClassControllerNotify& aOwner); + void ConstructL(); + +#ifdef _UNITTEST_DEBUG +public: +#else +private: +#endif + + void ReadMassStorageConfigL(); + void ConfigItem(const TPtrC& source, TDes& target, TInt maxLength); + +private: + RUsbMassStorage iUsbMs; +#ifdef _UNITTEST_DEBUG +public: +#endif + TMassStorageConfig iMsConfig; + }; + +#endif //__CUSBMSCLASSCONTROLLER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/inc/usbms.rh --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/inc/usbms.rh Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,28 @@ +/* +* Copyright (c) 2004-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: +* Resource header for usbman configuration. +* +*/ + +/** + @file +*/ + +STRUCT USBMASSSTORAGE_CONFIG + { + LTEXT vendorId; // no more than 8 characters + LTEXT productId; // no more than 16 characters + LTEXT productRev; // no more than 4 characters + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/src/10204bbb.rss --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/src/10204bbb.rss Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,41 @@ +/* +* Copyright (c) 2004-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 + +RESOURCE REGISTRY_INFO theInfo + { + dll_uid = 0x10204bbb; + interfaces = + { + INTERFACE_INFO + { + interface_uid = 0x101fbf21; + implementations = + { + IMPLEMENTATION_INFO + { + implementation_uid = 0x10204bbc; + version_no = 1; + display_name = "mass storage"; + default_data = ""; + opaque_data = ""; + } + }; + } + }; + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/src/CUsbMsClassController.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/src/CUsbMsClassController.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,305 @@ +/* +* Copyright (c) 2004-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: +* Adheres to the UsbMan USB Class Controller API and talks to mass storage +* file server +* +*/ + +/** + @file + @internalTechnology +*/ + +#include +#include +#include +#include +#include +#include "CUsbMsClassController.h" +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "MSCC"); +#endif + +// Panic category +#ifdef _DEBUG +_LIT( KMsCcPanicCategory, "UsbMsCc" ); +#endif + +/** + Panic codes for the USB mass storage Class Controller. + */ +enum TMsCcPanic + { + //Class called while in an illegal state + EBadApiCall = 0, + EUnusedFunction = 1, + }; + +/** + Constructs a CUsbMsClassController object + + @param aOwner USB Device that owns and manages the class + @return A new CUsbMsClassController object + */ +CUsbMsClassController* CUsbMsClassController::NewL( + MUsbClassControllerNotify& aOwner) + { + LOG_STATIC_FUNC_ENTRY + + CUsbMsClassController* r = new (ELeave) CUsbMsClassController(aOwner); + CleanupStack::PushL(r); + r->ConstructL(); + CleanupStack::Pop(); + return r; + } + +/** + Destructor + */ +CUsbMsClassController::~CUsbMsClassController() + { + Cancel(); + } + +/** + Constructor. + + @param aOwner USB Device that owns and manages the class + */ +CUsbMsClassController::CUsbMsClassController( + MUsbClassControllerNotify& aOwner) + : CUsbClassControllerPlugIn(aOwner, KMsStartupPriority) + { + // Intentionally left blank + } + +/** + 2nd Phase Construction. + */ +void CUsbMsClassController::ConstructL() + { + LOG_FUNC + + ReadMassStorageConfigL(); + } + +/** + Called by UsbMan when it wants to start the mass storage class. + + @param aStatus The caller's request status, filled in with an error code + */ +void CUsbMsClassController::Start(TRequestStatus& aStatus) + { + LOG_FUNC + + // The service state should always be idle when this function is called + // (guaranteed by CUsbSession). + __ASSERT_DEBUG( iState == EUsbServiceIdle, _USB_PANIC(KMsCcPanicCategory, EBadApiCall) ); + + TRequestStatus* reportStatus = &aStatus; + + iState = EUsbServiceStarting; + + // Connect to USB Mass Storage server + TInt err = iUsbMs.Connect(); + + if (err != KErrNone) + { + iState = EUsbServiceIdle; + User::RequestComplete(reportStatus, err); + LOGTEXT(_L8("Failed to connect to mass storage file server")); + return; + } + + // Start mass storage device + err = iUsbMs.Start(iMsConfig); + + if (err != KErrNone) + { + iState = EUsbServiceIdle; + + // Connection was created successfully in last step + // Get it closed since failed to start device. + iUsbMs.Close(); + + User::RequestComplete(reportStatus, err); + LOGTEXT(_L8("Failed to start mass storage device")); + return; + } + + iState = EUsbServiceStarted; + + User::RequestComplete(reportStatus, KErrNone); + } + +/** + Called by UsbMan when it wants to stop the USB ACM class. + + @param aStatus KErrNone on success or a system wide error code + */ +void CUsbMsClassController::Stop(TRequestStatus& aStatus) + { + LOG_FUNC + + // The service state should always be started when this function is called + // (guaranteed by CUsbSession) + __ASSERT_DEBUG( iState == EUsbServiceStarted, _USB_PANIC(KMsCcPanicCategory, EBadApiCall) ); + + TRequestStatus* reportStatus = &aStatus; + + TInt err = iUsbMs.Stop(); + + if (err != KErrNone) + { + iState = EUsbServiceStarted; + User::RequestComplete(reportStatus, err); + LOGTEXT(_L8("Failed to stop mass storage device")); + return; + } + + iUsbMs.Close(); + + User::RequestComplete(reportStatus, KErrNone); + } + +/** + Gets information about the descriptor which this class provides. Never called + by usbMan. + + @param aDescriptorInfo Descriptor info structure filled in by this function + */ +void CUsbMsClassController::GetDescriptorInfo(TUsbDescriptor& /*aDescriptorInfo*/) const + { + __ASSERT_DEBUG( EFalse, _USB_PANIC(KMsCcPanicCategory, EUnusedFunction)); + } + +/** + Standard active object RunL. Never called because this class has no + asynchronous requests. + */ +void CUsbMsClassController::RunL() + { + __ASSERT_DEBUG( EFalse, _USB_PANIC(KMsCcPanicCategory, EUnusedFunction) ); + } + +/** + Standard active object cancellation function. Never called because this + class has no asynchronous requests. + */ +void CUsbMsClassController::DoCancel() + { + __ASSERT_DEBUG( EFalse, _USB_PANIC(KMsCcPanicCategory, EUnusedFunction) ); + } + +/** + Standard active object error function. Never called because this class has + no asynchronous requests, and hence its RunL is never called. + + @param aError The error code (unused) + @return Always KErrNone to avoid an active scheduler panic + */ +TInt CUsbMsClassController::RunError(TInt /*aError*/) + { + __ASSERT_DEBUG( EFalse, _USB_PANIC(KMsCcPanicCategory, EUnusedFunction) ); + return KErrNone; + } + +/** + Read mass storage configuration info from the resource file + */ +void CUsbMsClassController::ReadMassStorageConfigL() + { + LOG_FUNC + + // Try to connect to file server + RFs fs; + LEAVEIFERRORL(fs.Connect()); + CleanupClosePushL(fs); + + RResourceFile resource; + TRAPD(err, resource.OpenL(fs, KUsbMsResource)); + LOGTEXT2(_L8("Opened resource file with error %d"), err); + + if (err != KErrNone) + { + LOGTEXT(_L8("Unable to open resource file")); + CleanupStack::PopAndDestroy(&fs); + return; + } + + CleanupClosePushL(resource); + + resource.ConfirmSignatureL(KUsbMsResourceVersion); + + HBufC8* msConfigBuf = 0; + TRAPD(ret, msConfigBuf = resource.AllocReadL(USBMS_CONFIG)); + if (ret != KErrNone) + { + LOGTEXT(_L8("Failed to open mass storage configuration file")); + CleanupStack::PopAndDestroy(2, &fs); + return; + } + CleanupStack::PushL(msConfigBuf); + + + // The format of the USB resource structure is: + + /* + * STRUCT USBMASSSTORAGE_CONFIG + * { + * LTEXT vendorId; // no more than 8 characters + * LTEXT productId; // no more than 16 characters + * LTEXT productRev; // no more than 4 characters + * }; + */ + + // Note that the resource must be read in this order! + + TResourceReader reader; + reader.SetBuffer(msConfigBuf); + + TPtrC vendorId = reader.ReadTPtrC(); + TPtrC productId = reader.ReadTPtrC(); + TPtrC productRev = reader.ReadTPtrC(); + + // populate iMsConfig, truncate if exceeding limit + ConfigItem(vendorId, iMsConfig.iVendorId, 8); + ConfigItem(productId, iMsConfig.iProductId, 16); + ConfigItem(productRev, iMsConfig.iProductRev, 4); + + // Debugging + LOGTEXT2(_L8("vendorId = %S\n"), &vendorId); + LOGTEXT2(_L8("productId = %S\n"), &productId); + LOGTEXT2(_L8("productRev = %S\n"), &productRev); + + CleanupStack::PopAndDestroy(3, &fs); // msConfigBuf, resource, fs + } + +/** + Utility. Copies the data from TPtr to TBuf and checks data length + to make sure the source does not exceed the capacity of the target + */ + void CUsbMsClassController::ConfigItem(const TPtrC& source, TDes& target, TInt maxLength) + { + if (source.Length() < maxLength) + { + maxLength = source.Length(); + } + + target.Copy(source.Ptr(), maxLength); + } + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/src/CUsbMsClassImpCollection.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/src/CUsbMsClassImpCollection.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,40 @@ +/* +* Copyright (c) 2004-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: +* Defines the implementation collection for the mass storage class controller. +* +*/ + +/** + @file +*/ + +#include +#include +#include +#include +#include "CUsbMsClassController.h" + +// Define the private interface UIDs +const TImplementationProxy UsbCCImplementationTable[] = + { + IMPLEMENTATION_PROXY_ENTRY(0x10204bbc, CUsbMsClassController::NewL), + }; + +EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount) + { + aTableCount = sizeof(UsbCCImplementationTable) / sizeof(TImplementationProxy); + + return UsbCCImplementationTable; + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/src/usbms.rss --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/ms/classcontroller/src/usbms.rss Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,39 @@ +/* +* Copyright (c) 2004-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: +* Resource file for the USB mass storage configuration. +* +*/ + +/** + @file +*/ + +NAME MSCF + +#include +#include "usbms.rh" + +RESOURCE BA_RSS_SIGNATURE + { + signature = 1; + } + +RESOURCE USBMASSSTORAGE_CONFIG usbms_config + { + vendorId = "vendorId"; // no more than 8 characters + productId = "productId"; // no more than 16 characters + productRev = "rev"; // no more than 4 characters + } + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/obex/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/obex/bld.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,18 @@ +/* +* Copyright (c) 2007-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 "classcontroller/group/bld.inf" diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/obex/classcontroller/group/BLD.INF --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/obex/classcontroller/group/BLD.INF Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,19 @@ +/* +* Copyright (c) 2004-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: +* +*/ + +PRJ_TESTMMPFILES +ObexClassController.mmp diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/obex/classcontroller/group/ObexClassController.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/obex/classcontroller/group/ObexClassController.mmp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,48 @@ +/* +* 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: +* ObexClassController.dll USB Class Controller Plugin, ref CC which loads/Starts/Stops whatever Obex implementation is desired +* +*/ + +/** + @file +*/ + + +target obexclasscontroller.dll //Recommended unpaged +CAPABILITY CommDD NetworkControl NetworkServices LocalServices ProtServ +targettype plugin + +// ECom Dll recognition UID followed by the unique dll UID +UID 0x10009d8d 0x101fbf27 +VENDORID 0x70000001 + +SOURCEPATH ../src +SOURCE CUsbObexClassImpCollection.cpp +SOURCE CUsbObexClassController.cpp + +USERINCLUDE ../inc + +OS_LAYER_SYSTEMINCLUDE_SYMBIAN + + +start resource 101fbf27.rss +target obexclasscontroller.rsc +END + +LIBRARY euser.lib +LIBRARY usbclasscontroller.lib + +#include diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/obex/classcontroller/inc/CUsbObexClassController.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/obex/classcontroller/inc/CUsbObexClassController.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,81 @@ +/** +* 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: +* Adheres to the UsbMan USB Class API and manages the class. +* +* +*/ + + + +/** + @file +*/ + +#ifndef __CUSBOBEXCLASSCONTROLLER_H__ +#define __CUSBOBEXCLASSCONTROLLER_H__ + +#include +#include +#include + +const TInt KObexClassPriority = 2; + +const TInt KObexDescriptorLength = 18; +const TInt KObexMinNumEndpoints = 3; +const TInt KObexClassNumber = 0x02; +const TInt KObexNumInterfaces = 2; +const TInt KObexSubClassNumber = 0x0b; +const TInt KObexProtocolNumber = 0x0; +const TInt KObexTotalEndpoints = 2; + +const TInt KObexDataClass = 0x0A; +const TInt KObexDataSubClass = 0; +const TInt KObexAlt0 = 0; +const TInt KObexAlt1 = 1; +const TInt KObexFunctionalDescriptorLength = 5; +const TInt KObexInterfaceDescriptorLength = 9; + +_LIT(KUsbObexLddName, "eusbc"); +_LIT(KUsbObexIfc, "OBEX"); + +NONSHARABLE_CLASS(CUsbObexClassController) : public CUsbClassControllerPlugIn + { +public: // New functions. + static CUsbObexClassController* NewL(MUsbClassControllerNotify& aOwner); + +public: // Functions derived from CActive. + virtual void RunL(); + virtual void DoCancel(); + virtual TInt RunError(TInt aError); + +public: // Functions derived from CUsbClassControllerBase + virtual ~CUsbObexClassController(); + + virtual void Start(TRequestStatus& aStatus); + virtual void Stop(TRequestStatus& aStatus); + + virtual void GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const; + + +protected: + CUsbObexClassController(MUsbClassControllerNotify& aOwner); + TInt SetUpClassAndInterface(); + +private: + RDevUsbcClient iLdd; // USB logical device drive + RDevUsbcClient iLdd2; + }; + +#endif //__CUSBOBEXCLASSCONTROLLER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/obex/classcontroller/src/101fbf27.rss --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/obex/classcontroller/src/101fbf27.rss Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,41 @@ +/* +* 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: +* +*/ + +#include + +RESOURCE REGISTRY_INFO theInfo + { + dll_uid = 0x101fbf27; + interfaces = + { + INTERFACE_INFO + { + interface_uid = 0x101fbf21; + implementations = + { + IMPLEMENTATION_INFO + { + implementation_uid = 0x101fbf28; + version_no = 1; + display_name = "Obex"; + default_data = ""; + opaque_data = ""; + } + }; + } + }; + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/obex/classcontroller/src/CUsbObexClassController.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/obex/classcontroller/src/CUsbObexClassController.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,394 @@ +/* +* 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 "CUsbObexClassController.h" +#include +#include +#include + +#ifdef __FLOG_ACTIVE +_LIT8(KLogComponent, "OBEXCC"); +#endif + + +// Panic category only used in debug builds +#ifdef _DEBUG +_LIT( KObexCcPanicCategory, "UsbObexCc" ); +#endif + +/** + * Panic codes for the USB OBEX Class Controller. + */ +enum TObexCCPanic + { + /** Asynchronous function called (not needed, as all requests complete synchronously) */ + EUnusedFunction = 0, + /** Start() called while in an illegal state */ + EBadApiCallStart = 1, + /** Stop() called while in an illegal state */ + EBadApiCallStop = 2, + }; + +const TInt KMaxPacketTypeBulk=64; + +/** + * Constructs a CUsbObexClassController object. + * + * @param aOwner USB Device that owns and manages the class + * @return A new CUsbObexClassController object + */ +CUsbObexClassController* CUsbObexClassController::NewL( + MUsbClassControllerNotify& aOwner) + { + LOG_STATIC_FUNC_ENTRY + + CUsbObexClassController* self = + new (ELeave) CUsbObexClassController(aOwner); + return self; + } + +/** + * Constructor. + * + * @param aOwner USB Device that owns and manages the class + */ +CUsbObexClassController::CUsbObexClassController( + MUsbClassControllerNotify& aOwner) + : CUsbClassControllerPlugIn(aOwner, KObexClassPriority) + { + iState = EUsbServiceIdle; + } + +/** + * Destructor. + */ +CUsbObexClassController::~CUsbObexClassController() + { + Cancel(); + if (iState == EUsbServiceStarted) + { + iLdd.ReleaseInterface(0); + iLdd.Close(); + iLdd2.ReleaseInterface(1); + iLdd2.ReleaseInterface(0); + iLdd2.Close(); + } + } + +/** + * SetupClassAndInterface. + * + * Sets the interface for use. This involves finding an "Interrupt IN" endpoint + * and if found configuring the interface. + */ + + +TInt CUsbObexClassController::SetUpClassAndInterface() + { + TUsbcInterfaceInfoBuf ifc; + + HBufC16* string = KUsbObexIfc().Alloc(); + if (!string) + return KErrNoMemory; + + ifc().iString = string; + ifc().iClass.iClassNum = KObexClassNumber; + ifc().iClass.iSubClassNum = KObexSubClassNumber; + ifc().iClass.iProtocolNum = KObexProtocolNumber; + ifc().iTotalEndpointsUsed = 0; + + // Indicate that this interface does not expect any control transfers + // from EP0. + ifc().iFeatureWord |= KUsbcInterfaceInfo_NoEp0RequestsPlease; + + TInt err = iLdd.SetInterface(0, ifc); + + // Get the interface number for later + TBuf8<100> interfaceDescriptor; + iLdd.GetInterfaceDescriptor(0, interfaceDescriptor); + TUint8 OBEXIntNo = interfaceDescriptor.Ptr()[2]; + + delete string; + + if (err != KErrNone) + { + return err; + } + + TBuf8<200> desc(0); + + //Comms Class Header Functional Descriptor + + desc.Append(KObexFunctionalDescriptorLength); + desc.Append(KUsbDescType_CS_Interface); + desc.Append(0); + desc.Append(0x10); + desc.Append(0x01); + + // Obex Functional Descriptor + + desc.Append(KObexFunctionalDescriptorLength); + desc.Append(KUsbDescType_CS_Interface); + desc.Append(0x15); + desc.Append(0x00); + desc.Append(0x01); + + // Union Functional Descriptor + + desc.Append(KObexFunctionalDescriptorLength); + desc.Append(KUsbDescType_CS_Interface); + desc.Append(0x06); // descriptor type (Union) + desc.Append(OBEXIntNo); + int dataInt = OBEXIntNo + 1; + desc.Append(dataInt); + + err= iLdd.SetCSInterfaceDescriptorBlock(0, desc); + if (err!= KErrNone) + { + return err; + } + + err = iLdd2.Open(0); + if (err != KErrNone) + { + return err; + } + + TUsbcInterfaceInfoBuf dataifc; + + // Set data class interfaces + dataifc().iString = NULL; + dataifc().iClass.iClassNum = KObexDataClass; + dataifc().iClass.iSubClassNum = KObexDataSubClass; + dataifc().iClass.iProtocolNum = 0; + dataifc().iTotalEndpointsUsed = 0; + + // Indicate that this interface does not expect any control transfers + // from EP0. + dataifc().iFeatureWord |= KUsbcInterfaceInfo_NoEp0RequestsPlease; + + err = iLdd2.SetInterface(0, dataifc); + if (err != KErrNone) + { + iLdd2.Close(); + return err; + } + + TUsbDeviceCaps dCaps; + TInt ret = iLdd.DeviceCaps(dCaps); + if (ret != KErrNone) + return ret; + + + TInt n = dCaps().iTotalEndpoints; + if (n < KObexMinNumEndpoints) + return KErrGeneral; + + // Endpoints + TUsbcEndpointData data[KUsbcMaxEndpoints]; + TPtr8 dataptr(REINTERPRET_CAST(TUint8*, data), sizeof(data), sizeof(data)); + ret = iLdd.EndpointCaps(dataptr); + if (ret!= KErrNone) + return ret; + + // Set the active interface + + TUsbcInterfaceInfoBuf dataifc2; + TBool foundIn = EFalse; + TBool foundOut = EFalse; + + for (TInt i = 0; !(foundIn && foundOut) && i < n; i++) + { + const TUsbcEndpointCaps* caps = &data[i].iCaps; + if (data[i].iInUse) + continue; + + const TUint KBulkInFlags = KUsbEpTypeBulk | KUsbEpDirIn; + const TUint KBulkOutFlags = KUsbEpTypeBulk | KUsbEpDirOut; + + if (!foundIn && (caps->iTypesAndDir & KBulkInFlags) == KBulkInFlags) + { + dataifc2().iEndpointData[0].iType = KUsbEpTypeBulk; + dataifc2().iEndpointData[0].iDir = KUsbEpDirIn; + TInt maxSize = caps->MaxPacketSize(); + if (maxSize > KMaxPacketTypeBulk) + maxSize = KMaxPacketTypeBulk; + dataifc2().iEndpointData[0].iSize = maxSize; + foundIn = ETrue; + } + else if (!foundOut && (caps->iTypesAndDir & KBulkOutFlags) == KBulkOutFlags) + { + dataifc2().iEndpointData[1].iType = KUsbEpTypeBulk; + dataifc2().iEndpointData[1].iDir = KUsbEpDirOut; + TInt maxSize = caps->MaxPacketSize(); + if (maxSize > KMaxPacketTypeBulk) + maxSize = KMaxPacketTypeBulk; + dataifc2().iEndpointData[1].iSize = maxSize; + foundOut = ETrue; + } + } + + if (!(foundIn && foundOut)) + return KErrGeneral; + + dataifc2().iString = NULL; + dataifc2().iClass.iClassNum = KObexDataClass; + dataifc2().iClass.iSubClassNum = KObexDataSubClass; + dataifc2().iClass.iProtocolNum = 0; + dataifc2().iTotalEndpointsUsed = KObexTotalEndpoints; + + // Indicate that this interface does not expect any control transfers + // from EP0. + dataifc2().iFeatureWord |= KUsbcInterfaceInfo_NoEp0RequestsPlease; + + err = iLdd2.SetInterface(1, dataifc2); + if (err != KErrNone) + { + iLdd2.ReleaseInterface(0); + iLdd2.Close(); + return err; + + } + return KErrNone; + } + +/** + * Called by UsbMan to start this class. + * + * @param aStatus Will be completed with success or failure. + */ +void CUsbObexClassController::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(KObexCcPanicCategory, EBadApiCallStart) ); + + TRequestStatus* reportStatus = &aStatus; + + iState = EUsbServiceStarting; + + TInt err = User::LoadLogicalDevice(KUsbObexLddName); + if (err != KErrNone && err != KErrAlreadyExists) + { + User::RequestComplete(reportStatus, err); + iState = EUsbServiceIdle; + return; + } + + err = iLdd.Open(0); + if(err != KErrNone) + { + iState = EUsbServiceIdle; + User::RequestComplete(reportStatus, err); + + return; + } + + err = SetUpClassAndInterface(); + if (err != KErrNone) + { + iLdd.Close(); + 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 CUsbObexClassController::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(KObexCcPanicCategory, EBadApiCallStop) ); + + TRequestStatus* ReportStatus = &aStatus; + + iState = EUsbServiceStopping; + + // We should probably check the return codes of these calls and report that + // we couldn't stop if they fail. + iLdd.ReleaseInterface(0); + iLdd.Close(); + iLdd2.ReleaseInterface(1); + iLdd2.ReleaseInterface(0); + iLdd2.Close(); + + iState = EUsbServiceIdle; + + User::RequestComplete(ReportStatus, KErrNone); + } + + +/** + * Returns information about the interfaces supported by this class. + * + * @param aDescriptorInfo Will be filled in with interface information. + */ +void CUsbObexClassController::GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const + { + aDescriptorInfo.iNumInterfaces = KObexNumInterfaces; + aDescriptorInfo.iLength = KObexDescriptorLength; + } + +/** + * Standard active object RunL. + * + * This is never called as this class does not have any asynchronous requests + */ +void CUsbObexClassController::RunL() + { + __ASSERT_DEBUG(EFalse, _USB_PANIC(KObexCcPanicCategory, EUnusedFunction)); + } + +/** + * Standard active object cancellation function. + * + * Will only be called when an asynchronous request is currently active. + */ +void CUsbObexClassController::DoCancel() + { + __ASSERT_DEBUG(EFalse, _USB_PANIC(KObexCcPanicCategory, EUnusedFunction)); + } + +/** + * Standard active object error-handling function. + * + * Should return KErrNone to avoid an active scheduler panic. This function + * should never be called as there is another mechanism for catching errors. + */ + +TInt CUsbObexClassController::RunError(TInt /*aError*/) + { + __ASSERT_DEBUG(EFalse, _USB_PANIC(KObexCcPanicCategory, EUnusedFunction)); + return KErrNone; + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/obex/classcontroller/src/CUsbObexClassImpCollection.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/obex/classcontroller/src/CUsbObexClassImpCollection.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,41 @@ +/* +* 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: +* Defines the implementation collection for the USB Obex class controller. +* +*/ + +/** + @file +*/ + +#include +#include +#include +#include +#include "CUsbObexClassController.h" + +// Define the private interface UIDs +const TImplementationProxy UsbCCImplementationTable[] = + { + IMPLEMENTATION_PROXY_ENTRY(0x101fbf28, CUsbObexClassController::NewL), + }; + +EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount) + { + aTableCount = sizeof(UsbCCImplementationTable) / sizeof(TImplementationProxy); + + return UsbCCImplementationTable; + } + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/whcm/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/whcm/bld.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,18 @@ +/* +* Copyright (c) 2007-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 "classcontroller/group/bld.inf" diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/whcm/classcontroller/INC/CUsbWHCMClassController.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/whcm/classcontroller/INC/CUsbWHCMClassController.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,86 @@ +/** +* 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: +* Adheres to the UsbMan USB Class API and manages the class. +* +* +*/ + + + +/** + @file +*/ + +#ifndef __CUSBWHCMCLASSCONTROLLER_H__ +#define __CUSBWHCMCLASSCONTROLLER_H__ + +#include +#include +#include + +const TInt KWHCMPriority = 1; +const TInt KWHCMSubClass = 0x08; +const TInt KWHCMProtocol = 0; +const TInt KWHCMFuncDescID = 0x11; + +/** + * A structure to hold most of the data for the descriptors in a WHCM header. + * The rest is filled out dynamically. + */ +static const TUint8 WHCMheader[] = + { + // Comms Class Header Functional Desctriptor + 5, KUsbDescType_CS_Interface, 0, 0x10, 0x01, + + // WHCM Functional Descriptor + 5, KUsbDescType_CS_Interface, KWHCMFuncDescID, 0x00, 0x01, + + // Union Functional Descriptor + 4 /* length, updated later once subordinates are known */, KUsbDescType_CS_Interface, 0x06 + // interface number and subordinates added later + }; + +/** + * Class Controller for the WHCM union class. + */ +NONSHARABLE_CLASS(CUsbWHCMClassController) : public CUsbClassControllerPlugIn + { +public: // New functions. + static CUsbWHCMClassController* NewL( + MUsbClassControllerNotify& aOwner); + +public: // Functions derived from CActive. + virtual void RunL(); + virtual void DoCancel(); + virtual TInt RunError(TInt aError); + +public: // Functions derived from CUsbClassControllerBase + virtual ~CUsbWHCMClassController(); + + virtual void Start(TRequestStatus& aStatus); + virtual void Stop(TRequestStatus& aStatus); + + virtual void GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const; + +protected: + CUsbWHCMClassController(MUsbClassControllerNotify& aOwner); + void ConstructL(); + void SetUpWHCMDescriptorL(); + +private: + RDevUsbcClient iLdd; // USB logical device drive + }; + +#endif //__CUSBWHCMCLASSCONTROLLER_H__ diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/whcm/classcontroller/SRC/101fbf23.rss --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/whcm/classcontroller/SRC/101fbf23.rss Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,41 @@ +/* +* 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: +* +*/ + +#include + +RESOURCE REGISTRY_INFO theInfo + { + dll_uid = 0x101fbf23; + interfaces = + { + INTERFACE_INFO + { + interface_uid = 0x101fbf21; + implementations = + { + IMPLEMENTATION_INFO + { + implementation_uid = 0x101fbf24; + version_no = 1; + display_name = "WHCM"; + default_data = ""; + opaque_data = ""; + } + }; + } + }; + } diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/whcm/classcontroller/SRC/CUsbWHCMClassController.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/whcm/classcontroller/SRC/CUsbWHCMClassController.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,283 @@ +/* +* 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 +#include +#include +#include + +#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 +#include +#include +#include +#include "CUsbWHCMClassController.h" + +// Define the private interface UIDs +const TImplementationProxy UsbCCImplementationTable[] = + { + IMPLEMENTATION_PROXY_ENTRY(0x101fbf24, CUsbWHCMClassController::NewL), + }; + +EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount) + { + aTableCount = sizeof(UsbCCImplementationTable) / sizeof(TImplementationProxy); + + return UsbCCImplementationTable; + } + diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/whcm/classcontroller/group/WHCMClassController.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/whcm/classcontroller/group/WHCMClassController.mmp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,48 @@ +/* +* 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: +* WHCMClassController.dll USB Plugin, must be include in ROM if producing a WHCM device +* +*/ + +/** + @file +*/ + + +target whcmclasscontroller.dll //Recommended unpaged +CAPABILITY CommDD NetworkControl NetworkServices LocalServices ProtServ +targettype plugin + +// ECom Dll recognition UID followed by the unique dll UID +UID 0x10009d8d 0x101fbf23 +VENDORID 0x70000001 + +SOURCEPATH ../SRC +SOURCE CUsbWHCMClassImpCollection.cpp +SOURCE CUsbWHCMClassController.cpp + +USERINCLUDE ../INC + +OS_LAYER_SYSTEMINCLUDE_SYMBIAN + + +start resource 101fbf23.rss +target whcmclasscontroller.rsc +END + +LIBRARY euser.lib +LIBRARY usbclasscontroller.lib + +#include diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/classdrivers/whcm/classcontroller/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/classdrivers/whcm/classcontroller/group/bld.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,27 @@ +/* +* Copyright (c) 2005-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: +* OptionalClassControllers.inf +* Builds class controllers which may be included +* in a ROM at rombuild time but which are not required for +* the emulator +* +*/ + + +PRJ_MMPFILES + +#if !(defined(WINS) || defined(WINSCW)) +WHCMClassController.mmp // WHCM Class Controller plugin +#endif diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/device/inf-files/symusb2k-XP.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgr/device/inf-files/symusb2k-XP.inf Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,142 @@ +; Copyright (c) 2002-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: +; Symbian USB Phone Setup File +; +; + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; LICENSEES - SEE END OF FILE FOR CONFIGURATION SECTION ;; +;; ========= THE REST OF THIS FILE SHOULD NOT REQUIRE ;; +;; MODIFICATION FOR STANDARD DISTRIBUTIONS ;; +;; ;; +;; Comments with licensee instructions are preceeded by ;; +;; >>> so that they can be easily found and removed. ;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +[Version] +LayoutFile=layout.inf +Signature=$WINDOWS NT$ +Class=Modem +Provider=Symbian +CLASSGUID={4D36E96D-E325-11CE-BFC1-08002BE10318} +DriverVer =07/01/2001,5.1.2535.0 + +[Manufacturer] +Symbian=Models + +[ControlFlags] +ExcludeFromSelect= * + +[DestinationDirs] +FakeModemCopyFileSection=12 +DefaultDestDir=12 + +[Models] +%MODEL_NAME% = SymbianUSB, %MODEL_HARDWARE_ID% +;>>> Note: we recommend that each .INF file supports just one model and that multiple models +;>>> are handled by multiple .INF files + +[SymbianUSB.NT] +CopyFiles=FakeModemCopyFileSection +AddReg = All, MfgAddReg, Modem1.AddReg, EXTERNAL + +[SymbianUSB.NT.Services] +AddService=usbser, 0x00000000, LowerFilter_Service_Inst + +[SymbianUSB.NT.HW] +AddReg=LowerFilterAddReg + +[LowerFilterAddReg] +HKR,,"LowerFilters",0x00010000,"usbser" + +[LowerFilter_Service_Inst] +DisplayName = %MODEL_NAME% +ServiceType = 1 +StartType = 3 +ErrorControl = 0 +ServiceBinary = %12%\usbser.sys + +[FakeModemCopyFileSection] +usbser.sys,,,0x20 + +[All] +HKR,,FriendlyDriver,,unimodem.vxd +HKR,,DevLoader,,*vcomm + +HKR,,ConfigDialog,0,modemui.dll +HKR,,EnumPropPages,0,modemui.dll,EnumPropPages +HKR,,PortSubClass,1,02 +HKR, Init, 1,, "AT" +HKR, Responses, "OK", 1, 00, 00, 00,00,00,00, 00,00,00,00 +HKR, Responses, "ERROR", 1, 03, 00, 00,00,00,00, 00,00,00,00 + +[Modem1.AddReg] +HKR,, DeviceType, 1, 01 ; External +HKR,, DCB, 1, 1C,00,00,00, 00,c2,01,00, 15,20,00,00, 00,00, 0a,00, 0a,00, 08, 00, 00, 11, 13, 00, 00, 00 +HKR,, Properties, 1, 00,00,00,00, 32,00,00,00, ff,00,00,00, 00,00,00,00, 00,00,00,00, 30,00,00,00, 00,c2,01,00, 00,F4,01,00 +HKR, Init, 4,, "ATG1=2G11=2" + +[EXTERNAL] +HKR,, DeviceType, 1, 01 + +[MfgAddReg] +HKR,, InactivityScale, 1, 3c,00,00,00 +HKR, Init, 2,, "AT&FX1E0&D2&C1" +HKR, Init, 3,, "ATV1S0=0G44=0" +HKR, Monitor, 1,, "ATS0=0" +HKR, Monitor, 2,, "None" + +HKR, Hangup, 1,, "ATH" +HKR, Answer, 1,, "ATA" +HKR,, Reset,, "ATZ" +HKR, Settings, Prefix,, "AT" +HKR, Settings, Terminator,, "" +HKR, Settings, DialPrefix,, "D" +HKR, Settings, DialSuffix,, "" +HKR, Settings, FlowControl_Off,, "\Q0" +HKR, Settings, FlowControl_Hard,, "\Q3" +HKR, Settings, FlowControl_Soft,, "\Q1" +HKR, Settings, CallSetupFailTimer,, "S7=<#>" +HKR, Settings, InactivityTimeout,, "C26=<#>" + +HKR, Responses, "NO CARRIER" , 1, 04, 00, 00,00,00,00, 00,00,00,00 +HKR, Responses, "NO DIALTONE" , 1, 05, 00, 00,00,00,00, 00,00,00,00 +HKR, Responses, "BUSY" , 1, 06, 00, 00,00,00,00, 00,00,00,00 +HKR, Responses, "NO ANSWER" , 1, 07, 00, 00,00,00,00, 00,00,00,00 +HKR, Responses, "RING" , 1, 08, 00, 00,00,00,00, 00,00,00,00 +HKR, Responses, "DELAYED" , 1, 1d, 00, 00,00,00,00, 00,00,00,00 + +HKR, Responses, "CONNECT" , 1, 02, 00, 00,00,00,00, 00,00,00,00 +HKR, Responses, "CONNECT 9600" , 1, 02, 00, 80,25,00,00, 00,00,00,00 +HKR, Responses, "CONNECT 19200" , 1, 02, 00, 00,4b,00,00, 00,00,00,00 +HKR, Responses, "