// Copyright (c) 1999-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:
// Constants for the RFCOMM protocol
// 
//

#ifndef RFCOMMCONSTS_H
#define RFCOMMCONSTS_H

const TInt KRFCOMMPSM = 0x03;  // The PSM on which RFCOMM resides
const TUid KUidServiceRfcomm={0x100095FC};
const TUint KRFCOMMIncomingConnQueueSize=5;

const static TInt KRfcommMuxDisconnectingChannelTimeout = 1*1000000; // microseconds
const static TInt KRfcommIdleTimeout = 5*1000000;  

// This mux idle timeout value needs to take into account authentication
// occurring before the first DLC (not the muxer) is created hence 60 seconds
const static TInt KRfcommMuxIdleTimeoutOpening = 60*1000000;  

// This mux idle timeout value is used when the last DLC (not the muxer) has
// been closed
const static TInt KRfcommMuxIdleTimeoutClosing = 5*1000000;  
const static TInt KRfcommMuxConnectingChannelTimeout = 60*1000000;

const static TInt KMinRfcommDLCI = 2;
const static TInt KMaxRfcommDLCI = 0x3f; //0b111111
const static TInt KMaxRfcommPriority = 0x3f; //0b111111

// Frame layout

//	Used when decoding incoming frames
const static TInt KShortFrameHeaderLength = 3; // addr, ctrl, len
const static TInt KLongFrameHeaderLength = 4; // addr, ctrl , 2*len

//	Used when encoding outgoing frames
const static TInt KMaxFrameHeaderLength = 4; // addr, ctrl , 2*len
const static TInt KMaxCreditFrameHeaderLength = 5; // addr, ctrl , 2*len, credit

//	Used in calculation of RFCOMM MTU
const static TInt KFCSFieldLength = 1;

//	Used when encoding mux commands into a UIH frame
const static TInt KShortMuxCommandHeaderLength = 2;	// type, length
const static TInt KLongMuxCommandHeaderLength = 3;	// type, 2*length

const static TInt KMaxFrameOverhead = 5;  // addr, ctrl, len*2, fcs
const static TInt KMaxFrameCreditOverhead = 6;  // addr, ctrl, len*2, credit, fcs
const static TInt KMinFrameLength = 4;
const static TInt KFrameAddrOffset = 0;
const static TInt KFrameCtrlOffset = 1;
const static TInt KMinAllowedDataSize = 11;  //< Must fit a RPN frame
const static TUint8 KPollFinalBitmask = 0x10;
const static TUint8 KEABitmask = 0x01;
const static TUint8 KCRBitmask = 0x02;
const static TUint8 KDirectionMask = 0x01;
const static TUint8 KMuxDLCI = 0;
// Signalling constants
const static TUint8 KSABMCtrlField = 0x2F;
const static TUint8 KUACtrlField = 0x63;
const static TUint8 KDMCtrlField = 0x0F;
const static TUint8 KDISCCtrlField = 0x43;
const static TUint8 KUIHCtrlField = 0xEF;
//TRY_CBFC
const static TUint8 KUIHCBFCCtrlField = 0xFF; // UIH control field with poll bit set 
const static TUint8 KCBFCCommandFlag = 0xf0;
const static TUint8 KCBFCResponseFlag = 0xe0; // actually 0xe forwards
const static TUint8 KInitialCredit = 3; //given to remote at first PN negotiation
										// - any more floods L2CAP
const static TInt KRfcommSAPCBFCBufferMultiple = 7; //max credits after initial negotiation
													//KRfcommSAPCBFCBufferMultiple*MTU used
													//for buffer size
const static TUint8 KRfcommCreditsLowWaterMark = 3; //donate credits if RxCredit 
													//(remote proxy credit)
													//hits this value
// was 14 but seemed to lock up

// Note all these types have no CR or EA bits encoded
const static TInt KTestType =0x08;
const static TInt KPNType= 0x20;
const static TInt KRPNType= 0x24;
const static TInt KFConType= 0x28;
const static TInt KFCoffType= 0x18;
const static TInt KMSCType= 0x38;
const static TInt KNSCType= 0x04;
const static TInt KRLSType= 0x14;

const static TUint8 KRfcommCtrlFrameLengthByte = 0x01;  //< EA bit set, length 0
const static TInt KRfcommCtrlFrameSize = 4;

const static TInt KFrameTimerT1=60*1000000;  // 60 secs, defined in spec
const static TInt KFrameTimerT1SABM=300*1000000;  // 300 secs, defined in spec
const static TInt KFrameTimerT2=60*1000000;  // 60 secs, defined in spec

const static TInt KCtrlFrameType=1;
const static TInt KDataFrameType=2;
const static TInt KMuxCtrlFrameType=3;
const static TInt KCreditDataFrameType=4; //Shehla - added to ease Blogging

// Setup "constants"
const static TUint8 KInitialModemStatus = 0x46; //< RTC, RTR, DV set

const static TInt KMaxOutboundQLength = 10;
const static TInt KRfcommDefaultFrameSize = 131;
const static TInt KRfcommDefaultMTU = 127;  // actual data size
const static TInt KRfcommMaxMTU = 32768;  	// maximum allowed data size
const static TInt KMaxL2CAPMTUFor1LengthByte = 131;	//	Maximum L2CAP MTU where (for a full
													//	size RFCOMM frame) one length byte 
													//	would suffice.
													
/*	
Maximum L2CAP MTU that RFComm should allow its L2Cap bearer to configure.
This is based on the specified maximum information field size (32768)
together with associated header and FCS lengths.
Note: it might be assumed that we should use the longer length field
in this calculation. However this yields the value 32773 - 
and this has been rejected during interop with a Royaltech GPS device.
*/
const static TInt KMaxL2CAPMTUAllowed = 
		KRfcommMaxMTU+KShortFrameHeaderLength+KFCSFieldLength;

const static TInt KRfcommSAPBufferMultiple = 50;  //< n*MTU for buffer size
const static TInt KRfcommSAPBufferLowMultiple = 20; //< n*MTU is flow on level
const static TInt KRfcommSAPBufferHighMultiple = 40; //< n*MTU is flow off level

// Masks for interpreting signalling commands - moved to bt_sock.h

const static TUint8 KRPNRequestLength = 1;
const static TUint8 KRPNCommandLength = 8;
const static TUint8 KRPNResponseLength = 8;

const static TUint8 KFConCommandLength = 0;
const static TUint8 KFCoffCommandLength = 0;
const static TUint8 KNSCCommandLength = 1;
const static TUint8 KMSCCommandLength = 2;
const static TUint8 KRLSCommandLength = 2;

// Test Ioctl definitions
// NB. Client Ioctls must not have KInternalIoctlBit
// (0x80000000) set.
const static TUint KRFCOMMFConIoctl =	0x7FFFFFFF;
const static TUint KRFCOMMFCoffIoctl =	0x7FFFFFFE;


// Errors are in rfcommerrors.h

#endif