// 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 <bluetooth/logger.h>
#include <bt_sock.h>
#include "L2types.h"
#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_L2CAP);
#endif
TL2CapEntityInfo::TL2CapEntityInfo()
: iExtendedFeatures(ENoExtendedFeatures),
iLinkInfoState(EL2CapEntityInfoUndef)
{
LOG_FUNC
}
TL2CapEntityInfo::TL2CapEntityInfo(TUint8 aExtendedFeatures)
: iExtendedFeatures(aExtendedFeatures),
iLinkInfoState(EL2CapEntityInfoUndef)
{
LOG_FUNC
}
// ****************************************************************
// *** L2Cap Config Types
// ****************************************************************
// ****************************************************************
// *** MTU Option
// ****************************************************************
TMTUOption::TMTUOption(TUint16 aMTU)
: iMTU(aMTU)
{
LOG_FUNC
}
TMTUOption::TMTUOption(ML2CapConfigurationOption::TStandardOptionValue aStandardOption)
{
LOG_FUNC
switch(aStandardOption)
{
case ML2CapConfigurationOption::EAbsoluteMinimumValue:
iMTU = KAbsMinMTU;
break;
case ML2CapConfigurationOption::ESpecMinimumValue:
iMTU = KSpecMinMTU;
break;
case ML2CapConfigurationOption::EMaximumValue:
iMTU = KMaxMTU;
break;
case ML2CapConfigurationOption::EPreferredValue:
iMTU = KPreferredMTU;
break;
case ML2CapConfigurationOption::ESpecDefaultValue:
default:
iMTU = KDefaultMTU;
break;
};
}
TConfigOptionType TMTUOption::OptionType() const
{
LOG_FUNC
return EConfigOptionTypeMTU;
}
// Option operators
void TMTUOption::operator=(const ML2CapConfigurationOption& aOption)
{
LOG_FUNC
*this = (static_cast<const TMTUOption&>(aOption));
}
TBool TMTUOption::operator<=(const ML2CapConfigurationOption& aOption) const
{
LOG_FUNC
return *this <= (static_cast<const TMTUOption&>(aOption));
}
TBool TMTUOption::operator==(const ML2CapConfigurationOption& aOption) const
{
LOG_FUNC
return *this == (static_cast<const TMTUOption&>(aOption));
}
TBool TMTUOption::operator>(const ML2CapConfigurationOption& aOption) const
{
LOG_FUNC
return *this > (static_cast<const TMTUOption&>(aOption));
}
void TMTUOption::operator=(const TMTUOption& aOption)
{
LOG_FUNC
iMTU = aOption.iMTU;
}
TBool TMTUOption::operator<=(const TMTUOption& aOption) const
{
LOG_FUNC
return iMTU <= aOption.iMTU;
}
TBool TMTUOption::operator==(const TMTUOption& aOption) const
{
LOG_FUNC
return iMTU == aOption.iMTU;
}
TBool TMTUOption::operator>(const TMTUOption& aOption) const
{
LOG_FUNC
return iMTU > aOption.iMTU;
}
// ****************************************************************
// *** Flush Timer Option
// ****************************************************************
TFlushTimeoutDurationOption::TFlushTimeoutDurationOption(TUint16 aFlushTimeoutDuration)
: iFlushTimeoutDuration(aFlushTimeoutDuration)
{
LOG_FUNC
}
TFlushTimeoutDurationOption::TFlushTimeoutDurationOption(ML2CapConfigurationOption::TStandardOptionValue aStandardOption)
{
LOG_FUNC
switch(aStandardOption)
{
case ML2CapConfigurationOption::EAbsoluteMinimumValue:
case ML2CapConfigurationOption::ESpecMinimumValue:
iFlushTimeoutDuration = KMinFlush;
break;
case ML2CapConfigurationOption::EMaximumValue:
iFlushTimeoutDuration = KMaxFlush;
break;
case ML2CapConfigurationOption::EPreferredValue:
case ML2CapConfigurationOption::ESpecDefaultValue:
default:
iFlushTimeoutDuration = KDefaultFlush;
break;
};
}
TConfigOptionType TFlushTimeoutDurationOption::OptionType() const
{
LOG_FUNC
return EConfigOptionTypeFlushTimeoutDuration;
}
// Option operators
void TFlushTimeoutDurationOption::operator=(const ML2CapConfigurationOption& aOption)
{
LOG_FUNC
*this = (static_cast<const TFlushTimeoutDurationOption&>(aOption));
}
TBool TFlushTimeoutDurationOption::operator<=(const ML2CapConfigurationOption& aOption) const
{
LOG_FUNC
return *this <= (static_cast<const TFlushTimeoutDurationOption&>(aOption));
}
TBool TFlushTimeoutDurationOption::operator==(const ML2CapConfigurationOption& aOption) const
{
LOG_FUNC
return *this == (static_cast<const TFlushTimeoutDurationOption&>(aOption));
}
void TFlushTimeoutDurationOption::operator=(const TFlushTimeoutDurationOption& aOption)
{
LOG_FUNC
iFlushTimeoutDuration = aOption.iFlushTimeoutDuration;
}
TBool TFlushTimeoutDurationOption::operator<=(const TFlushTimeoutDurationOption& aOption) const
{
LOG_FUNC
return iFlushTimeoutDuration <= aOption.iFlushTimeoutDuration;
}
TBool TFlushTimeoutDurationOption::operator==(const TFlushTimeoutDurationOption& aOption) const
{
LOG_FUNC
return iFlushTimeoutDuration == aOption.iFlushTimeoutDuration;
}
// ****************************************************************
// *** Quality of Service Option
// ****************************************************************
TQualityOfServiceOption::TQualityOfServiceOption(TQOSServiceType aServiceType,
TUint32 aTokenRate,
TUint32 aTokenBucketSize,
TUint32 aPeakBandwidth,
TUint32 aLatency,
TUint32 aDelayVariation)
: iServiceType(aServiceType),
iTokenRate(aTokenRate),
iTokenBucketSize(aTokenBucketSize),
iPeakBandwidth(aPeakBandwidth),
iLatency(aLatency),
iDelayVariation(aDelayVariation)
{
LOG_FUNC
}
TQualityOfServiceOption::TQualityOfServiceOption(ML2CapConfigurationOption::TStandardOptionValue aStandardOption)
{
LOG_FUNC
switch(aStandardOption)
{
case ML2CapConfigurationOption::EAbsoluteMinimumValue:
case ML2CapConfigurationOption::ESpecMinimumValue:
iServiceType = ENoTraffic;
iTokenRate = KMinTokenRate;
iTokenBucketSize = KMinTokenBucketSize;
iPeakBandwidth = KMinPeakBandwidth;
iLatency = KMinLatency;
iDelayVariation = KMinDelayVariation;
break;
case ML2CapConfigurationOption::EMaximumValue:
iServiceType = EGuaranteed;
// These casts have been added to remove errors encountered
// using the WINS compiler. The casts will be optimised
// out by all other compilers that use class local constants.
iTokenRate = static_cast<TUint32>(KMaxTokenRate);
iTokenBucketSize = static_cast<TUint32>(KMaxTokenBucketSize);
iPeakBandwidth = static_cast<TUint32>(KMaxPeakBandwidth);
iLatency = static_cast<TUint32>(KMaxLatency);
iDelayVariation = static_cast<TUint32>(KMaxDelayVariation);
break;
case ML2CapConfigurationOption::EPreferredValue:
case ML2CapConfigurationOption::ESpecDefaultValue:
default:
iServiceType = EBestEffort;
iTokenRate = KDefaultTokenRate;
iTokenBucketSize = KDefaultTokenBucketSize;
iPeakBandwidth = KDefaultPeakBandwidth;
// These casts have been added to remove errors encountered
// using the WINS compiler. The casts will be optimised
// out by all other compilers that use class local constants.
iLatency = static_cast<TUint32>(KDefaultLatency);
iDelayVariation = static_cast<TUint32>(KDefaultDelayVariation);
break;
};
}
TConfigOptionType TQualityOfServiceOption::OptionType() const
{
LOG_FUNC
return EConfigOptionTypeQOS;
}
// Option operators
void TQualityOfServiceOption::operator=(const ML2CapConfigurationOption& aOption)
{
LOG_FUNC
*this = static_cast<const TQualityOfServiceOption&>(aOption);
}
TBool TQualityOfServiceOption::operator<=(const ML2CapConfigurationOption& aOption) const
{
LOG_FUNC
return *this <= static_cast<const TQualityOfServiceOption&>(aOption);
}
TBool TQualityOfServiceOption::operator==(const ML2CapConfigurationOption& aOption) const
{
LOG_FUNC
return *this == static_cast<const TQualityOfServiceOption&>(aOption);
}
void TQualityOfServiceOption::operator=(const TQualityOfServiceOption& aOption)
{
LOG_FUNC
iServiceType = aOption.iServiceType;
iTokenRate = aOption.iTokenRate;
iTokenBucketSize = aOption.iTokenBucketSize;
iPeakBandwidth = aOption.iPeakBandwidth;
iLatency = aOption.iLatency;
iDelayVariation = aOption.iDelayVariation;
}
TBool TQualityOfServiceOption::operator<=(const TQualityOfServiceOption& aOption) const
{
LOG_FUNC
return (iServiceType <= aOption.iServiceType &&
iTokenRate <= aOption.iTokenRate &&
iTokenBucketSize <= aOption.iTokenBucketSize &&
iPeakBandwidth <= aOption.iPeakBandwidth &&
iLatency <= aOption.iLatency &&
iDelayVariation <= aOption.iDelayVariation);
}
TBool TQualityOfServiceOption::operator==(const TQualityOfServiceOption& aOption) const
{
LOG_FUNC
return (iServiceType == aOption.iServiceType &&
iTokenRate == aOption.iTokenRate &&
iTokenBucketSize == aOption.iTokenBucketSize &&
iPeakBandwidth == aOption.iPeakBandwidth &&
iLatency == aOption.iLatency &&
iDelayVariation == aOption.iDelayVariation);
}
// ****************************************************************
// *** Retransmission and Flow Control Option
// ****************************************************************
TRetransmissionAndFlowControlOption::TRetransmissionAndFlowControlOption(TL2CapChannelMode aLinkMode,
TUint8 aTxWindowSize,
TUint8 aMaxTransmit,
TUint16 aRetransmissionTimeout,
TUint16 aMonitorTimeout,
TUint16 aMaximumPDUSize)
: iLinkMode(aLinkMode),
iTxWindowSize(aTxWindowSize),
iMaxTransmit(aMaxTransmit),
iRetransmissionTimeout(aRetransmissionTimeout),
iMonitorTimeout(aMonitorTimeout),
iMaximumPDUSize(aMaximumPDUSize)
{
LOG_FUNC
}
TRetransmissionAndFlowControlOption::TRetransmissionAndFlowControlOption(TL2CapChannelMode aMode, TBool aFillWithPreferredValues)
{
LOG_FUNC
iLinkMode = aMode;
if (aFillWithPreferredValues && aMode != EL2CAPBasicMode)
{
const TBool useEnhancedModes = (aMode == EL2CAPEnhancedRetransmissionMode || aMode == EL2CAPStreamingMode);
iTxWindowSize = useEnhancedModes ? KDefaultEnhancedTxWindowSize : KDefaultLegacyTxWindowSize;
iMaxTransmit = KDefaultNumberTransmit;
iRetransmissionTimeout = KDefaultRetransmissionTimeout;
iMonitorTimeout = KDefaultMonitorTimeout;
iMaximumPDUSize = KDefaultMaximumPDUSize;
}
else
{
iTxWindowSize = 0;
iMaxTransmit = 0;
iRetransmissionTimeout = 0;
iMonitorTimeout = 0;
iMaximumPDUSize = 0;
}
}
TConfigOptionType TRetransmissionAndFlowControlOption::OptionType() const
{
LOG_FUNC
return EConfigOptionTypeRTxAndFEC;
}
TBool TRetransmissionAndFlowControlOption::operator==(const TRetransmissionAndFlowControlOption& aOption) const
{
LOG_FUNC
TBool rCode = ETrue;
// If both options are basic mode then no need to check other parameters.
if(!(iLinkMode == EL2CAPBasicMode && aOption.iLinkMode == EL2CAPBasicMode))
{
if(!(iLinkMode == aOption.iLinkMode &&
iTxWindowSize == aOption.iTxWindowSize &&
iMaxTransmit == aOption.iMaxTransmit &&
iRetransmissionTimeout == aOption.iRetransmissionTimeout &&
iMonitorTimeout == aOption.iMonitorTimeout &&
iMaximumPDUSize == aOption.iMaximumPDUSize))
{
rCode = EFalse;
}
}
return rCode;
}
/*static*/ TBool TRetransmissionAndFlowControlOption::EnhancedMaxTransmitLessOrEqual(TUint aLeft, TUint aRight)
{
LOG_STATIC_FUNC
TBool inRelation = EFalse;
const TUint KInfinity = 0;
if (aRight == KInfinity)
{
inRelation = ETrue;
}
else if (aLeft == KInfinity)
{
inRelation = EFalse;
}
else
{
inRelation = (aLeft <= aRight);
}
return inRelation;
}
/*static*/ TBool TRetransmissionAndFlowControlOption::IsModeReliable(TL2CapChannelMode aMode)
{
LOG_STATIC_FUNC
if (aMode == EL2CAPRetransmissionMode || aMode == EL2CAPEnhancedRetransmissionMode)
{
return ETrue;
}
else
{
return EFalse;
}
}
/*static*/ TBool TRetransmissionAndFlowControlOption::IsModeValid(TL2CapChannelMode aMode)
{
LOG_STATIC_FUNC
switch (aMode)
{
case EL2CAPBasicMode:
case EL2CAPRetransmissionMode:
case EL2CAPFlowControlMode:
case EL2CAPEnhancedRetransmissionMode:
case EL2CAPStreamingMode:
return ETrue;
default:
return EFalse;
}
}
#ifdef __FLOG_ACTIVE
void TRetransmissionAndFlowControlOption::GetReadable(TDes& aBuf) const
{
LOG_FUNC
// Adjust KReadableDesSpaceRequired if you change this!
aBuf.AppendFormat(_L("Mode=%d; "), iLinkMode);
aBuf.AppendFormat(_L("TxWin=%d; "), iTxWindowSize);
aBuf.AppendFormat(_L("MaxXmit=%d; "),iMaxTransmit);
aBuf.AppendFormat(_L("RtxTo=%d; "), iRetransmissionTimeout);
aBuf.AppendFormat(_L("MonTo=%d; "), iMonitorTimeout);
aBuf.AppendFormat(_L("MPS=%d"), iMaximumPDUSize);
}
#endif
TL2CapDataControllerConfig::TL2CapDataControllerConfig(TL2CapChannelMode aLinkMode,
TUint8 aTXWindowSize,
TUint8 aMaxTransmit,
TUint16 aRetransmissionTimeout,
TUint16 aMonitorTimeout,
TUint8 aPeerTXWindowSize,
TUint16 aPeerRetransmissionTimeout,
TUint16 aIncomingMps,
TUint8 aPriority)
: iLinkMode(aLinkMode),
iTXWindowSize(aTXWindowSize),
iMaxTransmit(aMaxTransmit),
iIncomingMps(aIncomingMps),
iRetransmissionTimeout(aRetransmissionTimeout),
iMonitorTimeout(aMonitorTimeout),
iChannelPriority(aPriority),
iPeerTXWindowSize(aPeerTXWindowSize),
iPeerRetransmissionTimeout(aPeerRetransmissionTimeout)
{
LOG_FUNC
#ifdef _DEBUG
if(aLinkMode != EL2CAPBasicMode && aLinkMode != EL2CAPStreamingMode)
{
__ASSERT_DEBUG(aTXWindowSize > 0 && aTXWindowSize <= 63,
Panic(EL2CAPBadDataPlaneConfiguration));
}
#endif
}