MCL/sf/os/bt: comparison bluetooth/btstack/linkmgr/physicallinks.cpp

equal deleted inserted replaced

-:9f17f914e828
+:32ba20339036
 	}
 void CPhysicalLink::ConnectionComplete(THCIErrorCode aErr, const TBTConnect& aConn)
 	{
 	LOG_FUNC
-	if (aErr == KErrNone)
+	ConnectionComplete(CHciUtil::SymbianErrorCode(aErr), aConn);
+	}
+void CPhysicalLink::ConnectionComplete(TInt aResult, const TBTConnect& aConn)
+	{
+	if (aResult == KErrNone)
 		{
 		if(aConn.iLinkType == ESCOLink && !iSyncLogicalLink)
 			{
 			LOG(_L("Got a ConnectionComplete for a non-existant SCO link"))
 			//This situation can occur if ESock deletes the iSyncLogicalLink whilst it is waiting for
 			//a remote device to respond to a connection request.
 			iLinksMan.Baseband().UpdateModelForConnectionError(aConn.iBdaddr, aConn.iLinkType);
-			if(aErr==EOK) // if error, aConn.iConnH will refer to the ACL link used to initialise the SCO link, so dont disconnect that
+			//The baseband might actually have established a SCO link, so send a Disconnect.
-				{
+			//If no SCO link exists the command will fail gracefully.
-				//The baseband might actually have established a SCO link, so send a Disconnect.
+			TRAP_IGNORE(iLinksMan.HCIFacade().DisconnectL(aConn.iConnH, ERemoteUserEndedConnection));
-				//If no SCO link exists the command will fail gracefully.
-				TRAP_IGNORE(iLinksMan.HCIFacade().DisconnectL(aConn.iConnH, ERemoteUserEndedConnection));
-				}
 			return;
 			}
 		// update bb model
 			NotifyStateChange(event);
 			if (aConn.iEncryptMode)
 				{
 				// pretend there's been an encryption event
-				EncryptionChange(aErr, aConn.iConnH, aConn.iEncryptMode);
+				EncryptionChange(EOK, aConn.iConnH, aConn.iEncryptMode);
 				}
 			}
 		// This is assuming that our stack only allows one synchronous link per phy link.
 		// SCO (not eSCO) Link getting notified here.
 			// The KInvalidConnectionHandle test ensures that we ignore errored outgoing SCO connects.
 			return;
 			}
 		iLinksMan.Baseband().UpdateModelForConnectionError(aConn.iBdaddr, aConn.iLinkType);
-		NotifyLogicalLinkError(aConn.iLinkType, CHciUtil::SymbianErrorCode(aErr));
+		NotifyLogicalLinkError(aConn.iLinkType, aResult);
 		if (aConn.iLinkType == EACLLink)
 			{
 			// BT 1.2 says that as the ACL Link goes up and down, so does the physical link
 			// so if the ACL Link has gone, so has this
 			// for SCO we remain in place.
-			TBTBasebandEventNotification event(ENotifyPhysicalLinkError, CHciUtil::SymbianErrorCode(aErr));
+			TBTBasebandEventNotification event(ENotifyPhysicalLinkError, aResult);
 			NotifyStateChange(event);
 			delete this;
 			}
 		}
 	// ***Watchout*** delete this above: careful about code here
 TInt CPhysicalLink::Arbitrate(TBool aImmediately, TBool aLocalPriority)
 	{
 	LOG_FUNC
 	if (!IsConnected())
+		{
+		LOG(_L8("Physical link not connected, no arbitration executed"));
 		return KErrDisconnected;
+		}
-	if ( aImmediately )
+	// The arbitration delay object will decide how much delay
-		{
+	return iArbitrationDelay->Start(aImmediately, aLocalPriority);
-		iArbitrationDelay->Cancel();
-		return DoArbitrate(aLocalPriority);
-		}
-	else if (iArbitrationDelay->IsActive())
-		{
-		return KErrNone;
-		}
-	else
-		{
-		iArbitrationDelay->Start(aLocalPriority);
-		return KErrNone;
-		}
 	}
 TInt CPhysicalLink::DoArbitrate(TBool aLocalPriority)
 	{
+	LOG_FUNC
 	if (!IsConnected())
 		{
+		LOG(_L8("Physical link not connected, no arbitration executed"));
 		return KErrDisconnected;
 		}
 	//start arbitrate process with what our local controller supports
 	TUint8 allowedModesMask = EHoldMode | EParkMode | ESniffMode; // local features sorted out later
-	TBool roleSwitchAllowed = EFalse;
+	TBool roleSwitchAllowed = iLinksMan.LinkManagerProtocol().IsRoleSwitchSupportedLocally() && iLinksMan.RoleSwitchAllowed();
+	LOG2(_L8("Arbitration: link policy (LPM:0x%02x, Role:0x%x) - Prior to proxies"), allowedModesMask, roleSwitchAllowed);
-	if (iLinksMan.LinkManagerProtocol().IsRoleSwitchSupportedLocally() && iLinksMan.RoleSwitchAllowed())
-		{
-		roleSwitchAllowed = ETrue;
-		}
 	// ask proxies what they want from the PHY
-	TUint8 requestedModeMask = 0;
+	TUint16 requestedModeMask = 0; // mask of current LPM requests from proxy's
-	TUint8 requestedMode = 0;
+	static const TUint16 KExplicitActiveMode = 0x0100; // special bit for explicit active mode requests
-	TBool activeModeIsRequested = EFalse;
 	TSglQueIter<CBTProxySAP> iter(iProxySAPs);
 	while (iter)
 		{
 		CBTProxySAP* proxy = iter++;
-		requestedMode = proxy->GetRequestedModes();
+		TUint8 requestedMode = proxy->GetRequestedModes();
 		requestedModeMask |= requestedMode;
-		if (requestedMode == EActiveMode && proxy->RequestedActiveMode())
+		TBool explicitActiveModeRequest = proxy->RequestedActiveMode();
-			{
+		if (requestedMode == EActiveMode && explicitActiveModeRequest)
-			// An Active Mode request will override all other local low power mode requests
+			{
-			// but continue to collect the requirement from the other proxies..
+			requestedModeMask |= KExplicitActiveMode;
-			activeModeIsRequested = ETrue;
+			}
-			}
+		TUint8 allowedModes = proxy->GetAllowedModes();
-		allowedModesMask &= proxy->GetAllowedModes();
+		allowedModesMask &= allowedModes;
-		roleSwitchAllowed &= proxy->IsRoleSwitchAllowed();
-		}
+		TBool roleSwitchAllowedByProxy = proxy->IsRoleSwitchAllowed();
+		roleSwitchAllowed = roleSwitchAllowed && roleSwitchAllowedByProxy;
-	if (activeModeIsRequested)
-		{
+		LOG4(_L8("Arbitration: Proxy(0x%08x) - requested mode = 0x%04x, link policy (LPM:0x%02x, Role:0x%x)"), proxy, requestedMode, allowedModes, roleSwitchAllowedByProxy);
-		// Any Active Mode request will override all other low power mode requests,
+		}
-		// so overwrite the requestedModeMask but keep allowedModesMask and roleSwitchAllowed
+	LOG2(_L8("Arbitration: link policy (LPM:0x%02x, Role:0x%x) - after proxies"), allowedModesMask, roleSwitchAllowed);
-		// as specified by all the local proxies
-		requestedModeMask = EActiveMode;
-		}
 	// clear out modes not supported by local Controller
+	// Future improvement - what about modes supported by the remote device?
 	allowedModesMask &= iLinksMan.LinkManagerProtocol().ModesSupportedLocally();
+	LOG2(_L8("Arbitration: link policy (LPM:0x%02x, Role:0x%x) - only supported modes"), allowedModesMask, roleSwitchAllowed);
 	if(iOverrideParkRequests)
 		{
 		// We wish to ensure the physical link is not in PARK mode.
 		// The only way to guarantee this is to disallow PARK via the link policy settings.
 		allowedModesMask &= ~EParkMode;
 		}
+	LOG2(_L8("Arbitration: link policy (LPM:0x%02x, Role:0x%x) - overrides applied"), allowedModesMask, roleSwitchAllowed);
-	if(allowedModesMask != iLinkPolicy.LowPowerModePolicy()
-		|| roleSwitchAllowed != iLinkPolicy.IsSwitchAllowed())
+	// Controller policy for the connection may need updating
-		{
+	SetModesAllowed(allowedModesMask, roleSwitchAllowed);
-		// Controller policy for the connection needs updating
+	LOG2(_L8("Arbitration: link policy (LPM:0x%02x, Role:0x%x) - submitted"), allowedModesMask, roleSwitchAllowed);
-		SetModesAllowed(allowedModesMask, roleSwitchAllowed);
-		}
 	//If OverrideLPM flag is set, we do not disable LP modes via the link policy settings
 	//This is done because OverrideLPM should not prevent remotes putting us into an LPM
 	//Later on, when OverrideLPM flag is cancelled, it would allow us to enforce requested LPM
 	if(iOverrideLPMRequests)
 		{
 		// We need to ensure the physical link is in active mode.
 		allowedModesMask = EActiveMode;
 		}
+	LOG2(_L8("Arbitration: link policy (LPM:0x%02x, Role:0x%x) - post setting overrides applied"), allowedModesMask, roleSwitchAllowed);
-	TUint8 modeChangeMask = static_cast<TUint8>(requestedModeMask & allowedModesMask);
-	TUint8 modeCompareMask = 0;
+	TUint16 modeChangeMask = requestedModeMask & (static_cast<TUint16>(allowedModesMask)|KExplicitActiveMode);
+	TUint16 modeCompareMask = 0;
+	LOG2(_L8("Arbitration: mode change mask = 0x%04x, local priority = 0x%x"), modeChangeMask, aLocalPriority);
 	if(aLocalPriority)
 		{
 		// If we want local priority, we go with what we want to do
 		// irrespective of what the remote may have previously requested.
 		// because a remote device has changed it..
 		// modeCompareMask should start only having zero bits where
 		// requestedModeMask has a zero bit and iPreviousRequestedModeMask does not
 		// i.e. a mode is newly no longer requested.
-		modeCompareMask = requestedModeMask | ~iPreviousRequestedModeMask;
+		modeCompareMask = ~((requestedModeMask ^ iPreviousRequestedModeMask) & iPreviousRequestedModeMask);
 		// Remove bits from modeCompareMask that are not in allowedModesMask
 		// We cannot stay in a power mode that we do not allow.
-		modeCompareMask &= allowedModesMask;
+		modeCompareMask &= (static_cast<TUint16>(allowedModesMask)|KExplicitActiveMode);
 		}
+	LOG1(_L8("Arbitration: Comparison mask = 0x%04x"), modeCompareMask);
 	iPreviousRequestedModeMask = requestedModeMask; // Update previous requested to current value.
-	TUint8 currentModeMask = static_cast<TUint8>(iLinkState.LinkMode());
+	// get the current mode.
+	TBTLinkMode currentMode = iLinkState.LinkMode();
+	TUint16 currentModeMask = static_cast<TUint16>(currentMode);
+	if(currentModeMask == EActiveMode)
+		{
+		// if in active mode then could have been because of an explicit active mode request
+		currentModeMask |= KExplicitActiveMode;
+		}
+	LOG1(_L8("Arbitration: Current mode mask = 0x%04x"), currentModeMask);
 	if(modeCompareMask & currentModeMask)
 		{
+		LOG2(_L8("Arbitration: Comparison mask (0x%04x) matched, so staying in current mode (0x%04x)"), modeCompareMask, currentModeMask);
 		// The current state is the same as the permitted required role(s).
 		return KErrNone;
 		}
-	if(modeChangeMask == EActiveMode && currentModeMask != EActiveMode)
+	TBTLinkMode nextMode = EActiveMode;
-		{
+	// Determine which LPM we should be in (if any)
-		// The current low power mode should be exited.
+	if(modeChangeMask & KExplicitActiveMode)
-		return RequestActive();
+		{
-		}
+		nextMode = EActiveMode;
+		}
-	if(modeChangeMask != EActiveMode)
+	else if(modeChangeMask & EHoldMode)
 		{
-		if(currentModeMask != EActiveMode)
+		nextMode = EHoldMode;
-			{
+		}
-			// The system is currently in a low power mode.  Exit this before
+	else if(modeChangeMask & ESniffMode)
-			// entering the new mode.
+		{
-			TInt rerr = RequestActive();
+		nextMode = ESniffMode;
-			if(rerr != KErrNone)
+		}
+	else if(modeChangeMask & EParkMode)
+		{
+		nextMode = EParkMode;
+		}
+	LOG2(_L8("Arbitration: Arbitrating mode 0x%02x -> 0x%02x"), currentMode, nextMode);
+	if(nextMode != currentMode)
+		{
+		if(currentMode != EActiveMode)
+			{
+			LOG(_L8("Arbitration: Exiting existing LPM mode..."));
+			TInt err = RequestActive();
+			if(err != KErrNone)
 				{
-				return rerr;
+				return err;
 				}
 			}
+		if(nextMode == EHoldMode)
-		if(modeChangeMask & EHoldMode)
+			{
-			{
+			LOG(_L8("Arbitration: Entering Hold mode..."));
 			return RequestHold();
 			}
-		if(modeChangeMask & ESniffMode)
+		else if(nextMode == ESniffMode)
 			{
+			LOG(_L8("Arbitration: Entering Sniff mode..."));
 			return RequestSniff();
 			}
-		if(modeChangeMask & EParkMode)
+		else if(nextMode == EParkMode)
 			{
+			LOG(_L8("Arbitration: Entering Park mode..."));
 			return RequestPark();
 			}
-		}
+		else if(nextMode == EActiveMode)
+			{
-	// This point in the code is reached if the Link Policy settings are
+			LOG(_L8("Arbitration: Staying in Active mode..."));
-	// changed but the mode is not.	 Return OK error code.
+			return KErrNone;
+			}
+		// Shouldn't reach here, we have a strange mode
+		DEBUG_PANIC_LINENUM;
+		}
+	LOG(_L8("Arbitration: Already in correct LPM, not doing anything"));
 	return KErrNone;
 	}
 void CPhysicalLink::SetPassKey(const TDesC8& aPassKey)
 	{
 	}
 void CPhysicalLink::StartArbitrationTimer() const
 	{
 	LOG_FUNC
-	iArbitrationDelay->Start();
+	iArbitrationDelay->Restart();
 	}
-TInt CPhysicalLink::Connect(TBasebandPageTimePolicy aPolicy)
+void CPhysicalLink::Connect(TBasebandPageTimePolicy aPolicy)
 	{
 	LOG_FUNC
 	// assume that we will be master until told otherwise
 	ASSERT_DEBUG(!IsConnected());
 	TUint16 pkt = KHCIDefaultPacketType;
 	// optimise paging (as a best-effort attempt).
 	TBasebandTime pagetimeout = CalculatePageTimeout(aPolicy, psrm, clockOffset & KHCIClockOffsetValidBit);
 	iLinksMan.TryToChangePageTimeout(pagetimeout);
+	// Set state in anticipation of the connection
+	iLinkState.SetLinkState(TBTBasebandLinkState::ELinkPending);
+	iLinksMan.Baseband().UpdateModel(iDevice.Address(), pkt, EACLLink);
+	iLinkState.SetLinkRole(EMaster);
 	TRAPD(ret, iLinksMan.HCIFacade().ConnectL(iDevice.Address(), pkt, psrm, psm, clockOffset, allowRoleSwitch));
-	if(ret==KErrNone)
+	if(ret != KErrNone) // a physical link is in charge of it's own destiny.
 		{
-		iLinkState.SetLinkState(TBTBasebandLinkState::ELinkPending);
+		TBTConnect conn;
-		iLinksMan.Baseband().UpdateModel(iDevice.Address(), pkt, EACLLink);
+		conn.iBdaddr = BDAddr();
-		iLinkState.SetLinkRole(EMaster);
+		conn.iLinkType = EACLLink;
-		}
+		ConnectionComplete(ret, conn);
+		}
-	return ret;
 	}
 TInt CPhysicalLink::SCOConnect()
 /**
 	A utility service provided to the SCO transport
 		(aEvent.EventType() & ENotifySniffMode)||
 		(aEvent.EventType() & ENotifyParkMode)||
 		(aEvent.EventType() & ENotifyHoldMode)) &&
 		(aEvent.ErrorCode() == KErrNone))
 		{
-		iArbitrationDelay->Start();
+		iArbitrationDelay->Restart();
 		}
 	}
 /*static*/ TInt CPhysicalLink::TerminateCallback(TAny* aCPhysicalLink)
 	{
 	}
 // CArbitrationDelayTimer
 CArbitrationDelayTimer::CArbitrationDelayTimer(CPhysicalLink* aParent)
-	:CTimer(CActive::EPriorityStandard),
+	: CTimer(CActive::EPriorityStandard)
-	iParent(aParent)
+	, iParent(aParent)
 	{
 	LOG_FUNC
+	ASSERT_DEBUG(iParent);
+	CActiveScheduler::Add(this);
 	}
 void CArbitrationDelayTimer::ConstructL()
 	{
 	LOG_FUNC
 	CTimer::ConstructL();
-	CActiveScheduler::Add(this);
 	}
 CArbitrationDelayTimer* CArbitrationDelayTimer::NewL(CPhysicalLink* aParent)
 	{
 	LOG_STATIC_FUNC
 	self->ConstructL();
 	CleanupStack::Pop(self);
 	return self;
 	}
-void CArbitrationDelayTimer::Start(TBool aLocalPriority)
+TInt CArbitrationDelayTimer::Start(TBool aImmediate, TBool aLocalPriority)
 	{
 	LOG_FUNC
 	// Work out what the local priority will be now
-	TBool localPriority = iLocalPriority || aLocalPriority;
+	iLocalPriority = iLocalPriority || aLocalPriority;
-	Cancel(); // cancel current timer (will also reset priority so ...
+	LOG1(_L8("Arbitraion: Local Priority now %d"), iLocalPriority);
-	iLocalPriority = localPriority; // set the new priority)
+	if(aImmediate)
+		{
+		LOG(_L8("Arbitraion: Immediate Arbitration Requested..."));
+		CancelButPreserveLocalPriority();
+		return DoArbitrate();
+		}
+	else if(!IsActive())
+		{
+		LOG(_L8("Arbitraion: Arbitration requested, will execute after delay timer..."));
+		After(KBTArbitrationDelay);
+		}
+	else // timer is already on its way
+		{
+		LOG(_L8("Arbitraion: Arbitration delay timer still pending..."));
+		}
+	return KErrNone;
+	}
+void CArbitrationDelayTimer::Restart()
+	{
+	LOG_FUNC
+	LOG(_L8("Arbitraion: Arbitration timer restarted..."));
+	CancelButPreserveLocalPriority();
 	After(KBTArbitrationDelay);
+	}
+void CArbitrationDelayTimer::CancelButPreserveLocalPriority()
+	{
+	LOG_FUNC
+	TBool localPriority = iLocalPriority;
+	Cancel();
+	iLocalPriority = localPriority;
 	}
 void CArbitrationDelayTimer::RunL()
 /**
 Allow arbitration of low power modes when the timer expires
 **/
 	{
 	LOG_FUNC
-	if (iParent)
+	LOG(_L8("Arbitraion: Delayed Arbitration executing..."));
-		{
+	static_cast<void>(DoArbitrate()); // ignore the error (always has been...)
-		iParent->DoArbitrate(iLocalPriority);
+	}
-		}
+TInt CArbitrationDelayTimer::DoArbitrate()
+	{
+	LOG_FUNC
+	TBool localPriority = iLocalPriority;
+	iLocalPriority = EFalse;
+	return iParent->DoArbitrate(localPriority);
 	}
 void CArbitrationDelayTimer::DoCancel()
 	{
 	LOG_FUNC

branch	RCL_3
changeset 17	32ba20339036
parent 16	9f17f914e828
child 18	1f10b9300be6