--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/include/drivers/usbcshared.inl Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,634 @@
+// Copyright (c) 2000-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:
+// e32\include\drivers\usbcshared.inl
+// Kernel side definitions for the USB Device driver stack (PIL + LDD).
+//
+//
+
+/**
+ @file usbcshared.inl
+ @internalTechnology
+*/
+
+#ifndef __USBCSHARED_INL__
+#define __USBCSHARED_INL__
+
+//
+// --- DUsbClientController (USB PDD) ---
+//
+
+// --- Private member functions, used by controller itself ---
+
+const DBase* DUsbClientController::PEndpoint2ClientId(TInt aRealEndpoint) const
+ {
+ if (iRealEndpoints[aRealEndpoint].iLEndpoint)
+ return iRealEndpoints[aRealEndpoint].iLEndpoint->iInterface->iInterfaceSet->iClientId;
+ else
+ return NULL;
+ }
+
+
+TInt DUsbClientController::PEndpoint2LEndpoint(TInt aRealEndpoint) const
+ {
+ if (iRealEndpoints[aRealEndpoint].iLEndpoint)
+ return iRealEndpoints[aRealEndpoint].iLEndpoint->iLEndpointNum;
+ else
+ return -1;
+ }
+
+
+const TUsbcConfiguration* DUsbClientController::CurrentConfig() const
+ {
+ return (iCurrentConfig ? iConfigs[iCurrentConfig - 1] : NULL);
+ }
+
+
+TUsbcConfiguration* DUsbClientController::CurrentConfig()
+ {
+ return (iCurrentConfig ? iConfigs[iCurrentConfig - 1] : NULL);
+ }
+
+
+TBool DUsbClientController::InterfaceExists(TInt aNumber) const
+ {
+ const TInt num_ifcsets = iConfigs[0]->iInterfaceSets.Count();
+ RPointerArray<TUsbcInterfaceSet>& ifcsets = iConfigs[0]->iInterfaceSets;
+ for (TInt i = 0; i < num_ifcsets; i++)
+ {
+ if (ifcsets[i]->iInterfaceNumber == aNumber)
+ {
+ return ETrue;
+ }
+ }
+ return EFalse;
+ }
+
+
+TBool DUsbClientController::EndpointExists(TUint aAddress) const
+ {
+ // Ep0 doesn't have a "logical ep" pointer (there's no virtual endpoint zero);
+ // that's why this pointer being non-NULL is not a sufficient criterion for
+ // endpoint-existence. (Apart from that, ep0 always exists.)
+ const TInt idx = EpAddr2Idx(aAddress);
+ return ((idx < iDeviceTotalEndpoints) &&
+ ((iRealEndpoints[idx].iLEndpoint != NULL) ||
+ ((aAddress & KUsbEpAddress_Portmask) == 0)));
+ }
+
+
+void DUsbClientController::Buffer2Setup(const TAny* aBuf, TUsbcSetup& aSetup) const
+ {
+ // TUint8 index
+ aSetup.iRequestType = static_cast<const TUint8*>(aBuf)[0];
+ aSetup.iRequest = static_cast<const TUint8*>(aBuf)[1];
+ // TUint16 index from here!
+ aSetup.iValue = SWAP_BYTES_16((static_cast<const TUint16*>(aBuf))[1]);
+ aSetup.iIndex = SWAP_BYTES_16((static_cast<const TUint16*>(aBuf))[2]);
+ aSetup.iLength = SWAP_BYTES_16((static_cast<const TUint16*>(aBuf))[3]);
+ }
+
+
+TUint DUsbClientController::EpIdx2Addr(TUint aRealEndpoint) const
+ {
+ return ((aRealEndpoint << 7) & 0x80) | ((aRealEndpoint >> 1) & 0x0f);
+ }
+
+
+TUint DUsbClientController::EpAddr2Idx(TUint aAddress) const
+ {
+ return ((aAddress & 0x80) >> 7) | ((aAddress & 0x0f) << 1);
+ }
+
+
+void DUsbClientController::SetEp0DataOutVars(const TUsbcSetup& aPacket, const DBase* aClientId)
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::SetEp0DataOutVars()"));
+ iSetup = aPacket;
+ iEp0DataReceiving = ETrue;
+ iEp0DataReceived = 0;
+ iEp0ClientId = aClientId;
+ }
+
+
+void DUsbClientController::ResetEp0DataOutVars()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("DUsbClientController::ResetEp0DataOutVars()"));
+ iEp0DataReceiving = EFalse;
+ iEp0DataReceived = 0;
+ iEp0ClientId = NULL;
+ }
+
+
+TBool DUsbClientController::IsInTheRequestList(const TUsbcRequestCallback& aCallback)
+ {
+ const TInt irq = NKern::DisableAllInterrupts();
+ TSglQueIter<TUsbcRequestCallback> iter(iEp0ReadRequestCallbacks);
+ TUsbcRequestCallback* p;
+ while ((p = iter++) != NULL)
+ {
+ if (p == &aCallback)
+ {
+ NKern::RestoreInterrupts(irq);
+ return ETrue;
+ }
+ }
+ NKern::RestoreInterrupts(irq);
+ return EFalse;
+ }
+
+
+TBool DUsbClientController::IsInTheStatusList(const TUsbcStatusCallback& aCallback)
+ {
+ const TInt irq = NKern::DisableAllInterrupts();
+ TSglQueIter<TUsbcStatusCallback> iter(iStatusCallbacks);
+ TUsbcStatusCallback* p;
+ while ((p = iter++) != NULL)
+ {
+ if (p == &aCallback)
+ {
+ NKern::RestoreInterrupts(irq);
+ return ETrue;
+ }
+ }
+ NKern::RestoreInterrupts(irq);
+ return EFalse;
+ }
+
+
+TBool DUsbClientController::IsInTheEpStatusList(const TUsbcEndpointStatusCallback& aCallback)
+ {
+ const TInt irq = NKern::DisableAllInterrupts();
+ TSglQueIter<TUsbcEndpointStatusCallback> iter(iEpStatusCallbacks);
+ TUsbcEndpointStatusCallback* p;
+ while ((p = iter++) != NULL)
+ {
+ if (p == &aCallback)
+ {
+ NKern::RestoreInterrupts(irq);
+ return ETrue;
+ }
+ }
+ NKern::RestoreInterrupts(irq);
+ return EFalse;
+ }
+
+
+TBool DUsbClientController::IsInTheOtgFeatureList(const TUsbcOtgFeatureCallback& aCallback)
+ {
+ const TInt irq = NKern::DisableAllInterrupts();
+ TSglQueIter<TUsbcOtgFeatureCallback> iter(iOtgCallbacks);
+ TUsbcOtgFeatureCallback* p;
+ while ((p = iter++) != NULL)
+ {
+ if (p == &aCallback)
+ {
+ NKern::RestoreInterrupts(irq);
+ return ETrue;
+ }
+ }
+ NKern::RestoreInterrupts(irq);
+ return EFalse;
+ }
+
+//
+// --- Misc classes ---
+//
+
+// --- TUsbcClientCallback
+
+/** Constructor.
+ */
+TUsbcClientCallback::TUsbcClientCallback(DBase* aOwner, TDfcFn aCallback, TInt aPriority)
+ : iOwner(aOwner),
+ iDfc(aCallback, aOwner, aPriority)
+ {}
+
+
+/** Returns a pointer to the owner of this request.
+
+ @return A pointer to the owner of this request.
+*/
+DBase* TUsbcClientCallback::Owner() const
+ {
+ return iOwner;
+ }
+
+
+/** Executes the callback function set by the owner of this request.
+
+ @return KErrNone.
+*/
+TInt TUsbcClientCallback::DoCallback()
+ {
+ __ASSERT_DEBUG((NKern::CurrentContext() == EThread), Kern::Fault(KUsbPILPanicCat, __LINE__));
+ iDfc.Enque();
+ return KErrNone;
+ }
+
+
+/** Cancels the callback function set by the owner of this request.
+ */
+void TUsbcClientCallback::Cancel()
+ {
+ iDfc.Cancel();
+ }
+
+
+/** Sets the DFC queue used by the callback function.
+ @param aDfcQ DFC queue to be set
+ */
+void TUsbcClientCallback::SetDfcQ(TDfcQue* aDfcQ)
+ {
+ iDfc.SetDfcQ(aDfcQ);
+ }
+
+
+// --- TUsbcEndpointStatusCallback
+
+/** Constructor.
+ */
+TUsbcEndpointStatusCallback::TUsbcEndpointStatusCallback(DBase* aOwner, TDfcFn aCallback,
+ TInt aPriority)
+ : iOwner(aOwner),
+ iDfc(aCallback, aOwner, aPriority),
+ iState(0)
+ {}
+
+
+/** Sets the state of this request to aState.
+
+ @param aState The new state to be set.
+*/
+void TUsbcEndpointStatusCallback::SetState(TUint aState)
+ {
+ iState = aState;
+ }
+
+
+/** Returns the state value of this request.
+
+ @return The state value of this request.
+*/
+TUint TUsbcEndpointStatusCallback::State() const
+ {
+ return iState;
+ }
+
+
+/** Returns a pointer to the owner of this request.
+
+ @return A pointer to the owner of this request.
+*/
+DBase* TUsbcEndpointStatusCallback::Owner() const
+ {
+ return iOwner;
+ }
+
+
+/** Executes the callback function set by the owner of this request.
+
+ @return KErrNone.
+*/
+TInt TUsbcEndpointStatusCallback::DoCallback()
+ {
+ if (NKern::CurrentContext() == EThread)
+ iDfc.Enque();
+ else
+ iDfc.Add();
+ return KErrNone;
+ }
+
+
+/** Cancels the callback function set by the owner of this request.
+*/
+void TUsbcEndpointStatusCallback::Cancel()
+ {
+ iDfc.Cancel();
+ }
+
+
+/** Sets the DFC queue used by the callback function.
+*/
+void TUsbcEndpointStatusCallback::SetDfcQ(TDfcQue* aDfcQ)
+ {
+ iDfc.SetDfcQ(aDfcQ);
+ }
+
+
+// --- TUsbcStatusCallback
+
+/** Constructor.
+ */
+TUsbcStatusCallback::TUsbcStatusCallback(DBase* aOwner, TDfcFn aCallback, TInt aPriority)
+ : iOwner(aOwner),
+ iDfc(aCallback, aOwner, aPriority)
+ {
+ ResetState();
+ }
+
+
+/** Sets the state of this request to aState (at the first available position
+ in the state value array).
+
+ @param aState The new state to be set.
+*/
+void TUsbcStatusCallback::SetState(TUsbcDeviceState aState)
+ {
+ for (TInt i = 0; i < KUsbcDeviceStateRequests; i++)
+ {
+ if (iState[i] == EUsbcNoState)
+ {
+ iState[i] = aState;
+ return;
+ }
+ }
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: KUsbcDeviceStateRequests too small (%d)!",
+ KUsbcDeviceStateRequests));
+ }
+
+
+/** Returns the state value of this request at a certain index.
+
+ @param aIndex The index to be used for referencing the state array.
+
+ @return The state value of this request at aIndex.
+*/
+TUsbcDeviceState TUsbcStatusCallback::State(TInt aIndex) const
+ {
+ if (aIndex >= 0 && aIndex < KUsbcDeviceStateRequests)
+ {
+ return iState[aIndex];
+ }
+ else
+ {
+ __KTRACE_OPT(KPANIC, Kern::Printf(" Error: aIndex too large (%d)!", aIndex));
+ return EUsbcNoState;
+ }
+ }
+
+
+/** Resets the entire state value array of this request.
+*/
+void TUsbcStatusCallback::ResetState()
+ {
+ for (TInt i = 0; i < KUsbcDeviceStateRequests; ++i)
+ {
+ iState[i] = EUsbcNoState;
+ }
+ }
+
+
+/** Returns a pointer to the owner of this request.
+
+ @return A pointer to the owner of this request.
+*/
+DBase* TUsbcStatusCallback::Owner() const
+ {
+ return iOwner;
+ }
+
+
+/** Executes the callback function set by the owner of this request.
+
+ @return KErrNone.
+*/
+TInt TUsbcStatusCallback::DoCallback()
+ {
+ if (NKern::CurrentContext() == EThread)
+ iDfc.Enque();
+ else
+ iDfc.Add();
+ return KErrNone;
+ }
+
+
+/** Cancels the callback function set by the owner of this request.
+*/
+void TUsbcStatusCallback::Cancel()
+ {
+ iDfc.Cancel();
+ }
+
+
+/** Sets the DFC queue used by the callback function.
+*/
+void TUsbcStatusCallback::SetDfcQ(TDfcQue* aDfcQ)
+ {
+ iDfc.SetDfcQ(aDfcQ);
+ }
+
+// --- TUsbcRequestCallback
+
+/** Constructor.
+ */
+TUsbcRequestCallback::TUsbcRequestCallback(const DBase* aOwner, TInt aEndpointNum, TDfcFn aDfcFunc,
+ TAny* aEndpoint, TDfcQue* aDfcQ, TInt aPriority)
+ : iEndpointNum(aEndpointNum),
+ iRealEpNum(-1),
+ iOwner(aOwner),
+ iDfc(aDfcFunc, aEndpoint, aDfcQ, aPriority),
+ iTransferDir(EControllerNone),
+ iBufferStart(NULL),
+ iPacketIndex(NULL), // actually TUint16 (*)[]
+ iPacketSize(NULL), // actually TUint16 (*)[]
+ iLength(0),
+ iZlpReqd(EFalse),
+ iTxBytes(0),
+ iRxPackets(0),
+ iError(KErrNone)
+ {
+ }
+
+
+/** Destructor.
+ */
+TUsbcRequestCallback::~TUsbcRequestCallback()
+ {
+ __KTRACE_OPT(KUSB, Kern::Printf("TUsbcRequestCallback::~TUsbcRequestCallback()"));
+ iDfc.Cancel();
+ }
+
+
+/** Sets some data members of this request for a read request.
+
+ @param aBufferStart The start of the data buffer to be filled.
+ @param aBufferAddr The physical address of the buffer (used for DMA).
+ @param aPacketIndex A pointer to the packet index values array.
+ @param aPacketSize A pointer to the packet size values array.
+ @param aLength The number of bytes to be received.
+*/
+void TUsbcRequestCallback::SetRxBufferInfo(TUint8* aBufferStart, TPhysAddr aBufferAddr,
+ TUsbcPacketArray* aPacketIndex,
+ TUsbcPacketArray* aPacketSize,
+ TInt aLength)
+ {
+ iTransferDir = EControllerRead;
+ iBufferStart = aBufferStart;
+ iBufferAddr = aBufferAddr;
+ iPacketIndex = aPacketIndex;
+ iPacketSize = aPacketSize;
+ iLength = aLength;
+ }
+
+
+/** Sets some data members of this request for a write request.
+
+ @param aBufferStart The start of the buffer that contains the data to be sent.
+ @param aBufferAddr The physical address of the buffer (used for DMA).
+ @param aLength The number of bytes to be transmitted.
+*/
+void TUsbcRequestCallback::SetTxBufferInfo(TUint8* aBufferStart, TPhysAddr aBufferAddr, TInt aLength)
+ {
+ iTransferDir = EControllerWrite;
+ iBufferStart = aBufferStart;
+ iBufferAddr = aBufferAddr;
+ iLength = aLength;
+ }
+
+
+/** Sets the transfer direction for this request.
+
+ @param aTransferDir The new transfer direction.
+*/
+void TUsbcRequestCallback::SetTransferDirection(TTransferDirection aTransferDir)
+ {
+ iTransferDir = aTransferDir;
+ }
+
+
+/** Returns a pointer to the owner of this request.
+
+ @return A pointer to the owner of this request.
+*/
+const DBase* TUsbcRequestCallback::Owner() const
+ {
+ return iOwner;
+ }
+
+
+/** Executes the callback function set by the owner of this request.
+
+ @return KErrNone.
+*/
+TInt TUsbcRequestCallback::DoCallback()
+ {
+ if (NKern::CurrentContext() == NKern::EThread)
+ iDfc.Enque();
+ else
+ iDfc.Add();
+ return KErrNone;
+ }
+
+
+/** Cancels the callback function set by the owner of this request.
+*/
+void TUsbcRequestCallback::Cancel()
+ {
+ iDfc.Cancel();
+ }
+
+// --- TUsbcOtgFeatureCallback
+
+/** Constructor.
+ */
+TUsbcOtgFeatureCallback::TUsbcOtgFeatureCallback(DBase* aOwner, TDfcFn aCallback,
+ TInt aPriority)
+ : iOwner(aOwner),
+ iDfc(aCallback, aOwner, aPriority),
+ iValue(0)
+ {}
+
+
+/** Returns a pointer to the owner of this request.
+ @return A pointer to the owner of this request.
+*/
+DBase* TUsbcOtgFeatureCallback::Owner() const
+ {
+ return iOwner;
+ }
+
+
+/** Set feature value which is to be notified to client.
+ @param OTG feature value to be set
+*/
+void TUsbcOtgFeatureCallback::SetFeatures(TUint8 aFeatures)
+ {
+ iValue = aFeatures;
+ }
+
+
+/** Set feature value which is to be notified to client.
+ @return Value of OTG features
+*/
+TUint8 TUsbcOtgFeatureCallback::Features() const
+ {
+ return iValue;
+ }
+
+
+/** Set DFC queue.
+ @param aDfcQ DFC queue to be set
+*/
+void TUsbcOtgFeatureCallback::SetDfcQ(TDfcQue* aDfcQ)
+ {
+ iDfc.SetDfcQ(aDfcQ);
+ }
+
+
+/** Executes the callback function set by the owner of this request.
+ @return KErrNone.
+*/
+TInt TUsbcOtgFeatureCallback::DoCallback()
+ {
+ if (NKern::CurrentContext() == EThread)
+ iDfc.Enque();
+ else
+ iDfc.Add();
+ return KErrNone;
+ }
+
+
+/** Cancels the callback function set by the owner of this request.
+ */
+void TUsbcOtgFeatureCallback::Cancel()
+ {
+ iDfc.Cancel();
+ }
+
+
+/** Returns a pointer to the currently selected (active) setting of this interface.
+
+ @return A pointer to the currently selected (active) setting of this interface.
+*/
+const TUsbcInterface* TUsbcInterfaceSet::CurrentInterface() const
+ {
+ return iInterfaces[iCurrentInterface];
+ }
+
+
+/** Returns a pointer to the currently selected (active) setting of this interface.
+
+ @return A pointer to the currently selected (active) setting of this interface.
+*/
+
+TUsbcInterface* TUsbcInterfaceSet::CurrentInterface()
+ {
+ return iInterfaces[iCurrentInterface];
+ }
+
+
+#endif // __USBCSHARED_INL__
+
+
+