--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/bluetooth/btstack/l2cap/l2types.cpp Fri Jan 15 08:13:17 2010 +0200
@@ -0,0 +1,495 @@
+// 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
+ }