diff -r 000000000000 -r a41df078684a kernel/eka/include/d32otgdi.inl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kernel/eka/include/d32otgdi.inl Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,368 @@ +// 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 the License "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 + @prototype + + The driver's name + + @return The name of the driver + + @internalComponent +*/ +inline const TDesC& RUsbOtgDriver::Name() + { + _LIT( KDriverName, "USBOTGDRIVER" ); + return KDriverName; + } + +/** + The driver's version + + @return The version number of the driver + + @internalComponent +*/ +inline TVersion RUsbOtgDriver::VersionRequired() + { + const TInt KBuildVersionNumber = KE32BuildVersionNumber; + + return TVersion( KMajorVersionNumber, KMinorVersionNumber, KBuildVersionNumber ); + } + +#ifndef __KERNEL_MODE__ + +/** + Open a a logical channel to the OTG driver + + @return System-wide error code giving status of connection attempt. +*/ +inline TInt RUsbOtgDriver::Open() + { + TInt rc = KErrNone; + + // Check to see if this object has already been opened - if it has, + // there will be a handle set. + + if ( Handle() ) + { + User::Panic(OtgdiPanics::KUsbOtgDriverPanicCat, OtgdiPanics::EUsbOtgDriverAlreadyOpened); + } + + rc = DoCreate( Name(), VersionRequired(), KNullUnit, NULL, NULL, EOwnerThread ); + + // We expect back KErrNone - any other problem indicates an attempt by + // the caller to double-open the driver, which is forbidden + + if ( rc != KErrNone ) + { + RDebug::Print(_L("********************************")); + RDebug::Print(_L("* RUsbOtgDriver::Open() Fault! *")); + RDebug::Print(_L("********************************")); + } + + return rc; + } + +/** + Special method to alter the default behaviour of the stack: + + Test mode is activated (special) + + @return Driver-specific error code or system-wide success +*/ +inline TInt RUsbOtgDriver::ActivateOptTestMode() + { + return DoControl( EActivateOptTestMode ); + } + +/** + Overall command to start USB stacks + + @return Driver-specific error code or system-wide success +*/ +inline TInt RUsbOtgDriver::StartStacks() + { + return DoControl( EStartStacks ); + } + +/** + Overall command to stop USB stacks +*/ +inline void RUsbOtgDriver::StopStacks() + { + static_cast(DoControl( EStopStacks )); + } + +/** + Generic event-reporting mechanism, provided in the form of a standard + watcher which registers and allows user to block until notification. + + To cater for rapidly-occurring events, this function will return the + earliest event code (assuming a FIFO stack model for recording such + events) + + The notification function does not support multiple instances, it is expected + to be limited solely to ownership by USBMAN + + @param aOldestEvent parameter to collect the TOtgEvent + @param aStatus standard request completion +*/ +inline void RUsbOtgDriver::QueueOtgEventRequest(TOtgEvent& aOldestEvent, TRequestStatus& aStatus) + { + DoRequest( EQueueOtgEventRequest, aStatus, &aOldestEvent ); + } + +/** + Cancellation method for event notification + + Note that the 'cancel' function does not return an error code in the event + that there is no registered watcher: it is assumed that the code + within will contain an ASSERT_DEBUG check to confirm watcher validity. +*/ +inline void RUsbOtgDriver::CancelOtgEventRequest() + { + static_cast(DoControl( ECancelOtgEventRequest )); + } + +/** + Generic state-reporting mechanism, provided in the form of a standard + watcher which registers and allows user to block until notification. + + To cater for rapidly-occurring changes, this function will return the + earliest state code (assuming a FIFO stack model for recording such + States) + + The notification function does not support multiple instances, it is expected + to be limited solely to ownership by USBMAN + + @param aState parameter to collect the TOtgState + @param aStatus standard request completion +*/ +inline void RUsbOtgDriver::QueueOtgStateRequest(TOtgState& aState, TRequestStatus& aStatus) + { + DoRequest( EQueueOtgStateRequest, aStatus, &aState ); + } + +/** + Cancellation method for state notification + + Note that the 'cancel' function does not return an error code in the event + that there is no registered watcher: it is assumed that the code + within will contain an ASSERT_DEBUG check to confirm watcher validity. +*/ +inline void RUsbOtgDriver::CancelOtgStateRequest() + { + static_cast(DoControl( ECancelOtgStateRequest )); + } + +/** + Generic message-reporting mechanism, provided in the form of a standard + watcher which registers and allows user to block until notification. + + To cater for rapidly-occurring changes, this function will return the + earliest message code (assuming a FIFO stack model for recording such + Messages) + + The notification function does not support multiple instances, it is expected + to be limited solely to ownership by USBMAN + + @param aMessage parameter to collect the TOtgMessage + @param aStatus standard request completion +*/ +inline void RUsbOtgDriver::QueueOtgMessageRequest(TOtgMessage& aMessage, TRequestStatus& aStatus) + { + DoRequest( EQueueOtgMessageRequest, aStatus, &aMessage ); + } + +/** + Cancellation method for message notification + + Note that the 'cancel' function does not return an error code in the event + that there is no registered watcher: it is assumed that the code + within will contain an ASSERT_DEBUG check to confirm watcher validity. +*/ +inline void RUsbOtgDriver::CancelOtgMessageRequest() + { + static_cast(DoControl( ECancelOtgMessageRequest )); + } + +/** + Single-purpose instant-report mechanism to return the current state + of the ID-Pin on the MIni/Micro-AB connector. + + This method is expected to complete immediately and return the + *current* state of the ID-Pin, it will omit any intermediate + changes that may have occurred since it was last called. + + @param aCurrentIdPin parameter to collect the ID-Pin state + @param aStatus standard request completion +*/ +inline void RUsbOtgDriver::QueueOtgIdPinNotification(TOtgIdPin& aCurrentIdPin, TRequestStatus& aStatus) + { + DoRequest( EQueueOtgIdPinNotification, aStatus, &aCurrentIdPin ); + } + +/** + Cancellation method for ID-Pin notification +*/ +inline void RUsbOtgDriver::CancelOtgIdPinNotification() + { + static_cast(DoControl( ECancelOtgIdPinNotification )); + } + +/** + Single-purpose instant-report mechanism to return the current state + of the Voltage level on the Mini/Micro-AB connector. + + This method is expected to complete immediately and return the + *current* state of the voltage, it will omit any intermediate + changes that may have occurred since it was last called. + + @param aCurrentVbus parameter to collect the voltage state + @param aStatus standard request completion +*/ +inline void RUsbOtgDriver::QueueOtgVbusNotification(TOtgVbus& aCurrentVbus, TRequestStatus& aStatus) + { + DoRequest( EQueueOtgVbusNotification, aStatus, &aCurrentVbus ); + } + +/** + Cancellation method for Vbus notification +*/ +inline void RUsbOtgDriver::CancelOtgVbusNotification() + { + static_cast(DoControl( ECancelOtgVbusNotification )); + } + +/** + Single-purpose instant-report mechanism to return the current state + of the permissive/advisory that indicates 'idle' state where it is + deemed safe to drop VBUS. + + This method is expected to complete immediately and return the + *current* state of the idleness, it will omit any intermediate + changes that may have occurred since it was last called. + + @param aCurrentIdle parameter to collect the idle state + @param aStatus standard request completion +*/ +inline void RUsbOtgDriver::QueueOtgConnectionNotification(TOtgConnection& aCurrentIdle, TRequestStatus& aStatus) + { + DoRequest( EQueueOtgConnectionNotification, aStatus, &aCurrentIdle ); + } + +/** + Cancellation method for Idle notification +*/ +inline void RUsbOtgDriver::CancelOtgConnectionNotification() + { + static_cast(DoControl( ECancelOtgConnectionNotification )); + } + +/** + Single-purpose instant-report mechanism to return the current state + of the OTG state machine + + This method is expected to complete immediately and return the + *current* state, it will omit any intermediate changes that may + have occurred since it was last called. + + @param aCurrentState parameter to collect the state + @param aStatus standard request completion +*/ +inline void RUsbOtgDriver::QueueOtgStateNotification(TOtgState& aCurrentState, TRequestStatus& aStatus) + { + DoRequest( EQueueOtgStateNotification, aStatus, &aCurrentState ); + } + +/** + Cancellation method for State notification +*/ +inline void RUsbOtgDriver::CancelOtgStateNotification() + { + static_cast(DoControl( ECancelOtgStateNotification )); + } + +/** + USBMAN wants to assert bus request for 'Host' or 'Peripheral' duty + + Default-Host: this will result in an attempt to raise Vbus + + Default-Device: this will result in an attempt to use SRP(+HNP) + + The bus request is asserted until BusDrop() is called. + + @return Error code returns are related to the current OTG state context + at the time of calling, and not to the asynchronous result + (which is reported via event notification) +*/ +inline TInt RUsbOtgDriver::BusRequest() + { + return DoControl( EBusRequest ); + } + +/** + USBMAN wants to permit use of the bus, in response to a request from + the other (B) end of the link to make use of it. + + @return Error code returns are related to the current OTG state context + at the time of calling, and not to the asynchronous result + (which is reported via event notification) +*/ +inline TInt RUsbOtgDriver::BusRespondSrp() + { + return DoControl( EBusRespondSrp ); + } + +/** + USBMAN wants to stop using the bus. + + This function can only be called from the A-Device and will result in + the voltage drive being removed from the Vbus line. + + @return Error code returns are related to the current OTG state context + at the time of calling, and not to the asynchronous result + (which is reported via event notification) + + In particular, this function will return an error code if it + is called in any 'B' state +*/ +inline TInt RUsbOtgDriver::BusDrop() + { + return DoControl( EBusDrop ); + } + +/** + USBMAN wants to clear the bus error state. + + This function can only be called from the A-Device and will result in + the OTG state machine being moved out of the A_VBUS_ERR state. + + @return Error code returns are related to the current OTG state context + at the time of calling, and not to the asynchronous result + (which is reported via event notification) + + In particular, this function will return an error code if it + is called in any 'B' state +*/ +inline TInt RUsbOtgDriver::BusClearError() + { + return DoControl( EBusClearError ); + } + +#endif // !__KERNEL_MODE__