l2cap.h

/******************************************************************************

 @file  l2cap.h

 @brief This file contains the Logical Link Control and Adaptation
        Layer (L2CAP) definitions and prototypes.
        
        <BR><BR> \image html
        HighLevelL2CAP.PNG
        
        <BR> <h2>Functional
        Description</h2> <p>The
        Logical Link Control and Adaptation Layer (L2CAP) protocol provides
        connection-oriented and connectionless data services to upper layer
        protocols with protocol multiplexing capability and segmentation and
        reassembly operation. The L2CAP protocol is packet-based but follows a
        communication model based on channels. A channel represents a data flow
        between L2CAP entities in remote devices.</p>
        
        <BR> <h2>L2CAP
        Services</h2> <p>The
        L2CAP layer provides the following services to upper level protocols
        and applications:</p> <ul <ul <ul <ul <ul <ul <ul <ul <ul <ul <ul <ul
        <ul> <li>Fixed and connection-oriented channels with protocol
        multiplexing capability:</li> <ul <ul <ul <ul <ul <ul <ul <ul <ul <ul
        <ul> <li>Attribute
        Protocol (ATT) channel (0x0004).</li> <li>Signaling channel
        (0x0005).</li> <li>Security
        Management Protocol (SMP) channel (0x0006).</li>
        <li>Connection-oriented channels (0x0040-0x007F).</li> </ul </ul </ul
        </ul> <li>Data transport services allowing upper level protocols and
        applications to transmit and receive upper layer
        Service Data Units (SDUs) up to:</li> <ul <ul <ul <ul <ul <ul <ul <ul
        <ul> <li>23 octets in length over a fixed channel. With
        HCI fragmentation and recombination operation enabled, applications can
        transmit and receive larger
        SDUs.</li> <li>512 octets in length over a connection-oriented channel
        with segmentation and reassembly operation.</li operation.</li
        operation.</li> </ul </ul </ul </ul </ul </ul </ul </ul </ul </ul </ul
        </ul> </ul </ul </ul </ul </ul </ul </ul </ul </ul </ul </ul </ul </ul
        </ul>
        
        <BR><BR><BR><BR>

 Group: WCS, BTS
 $Target Device: DEVICES $

 ******************************************************************************
 $License: TISD 2009 $
 ******************************************************************************
 $Release Name: PACKAGE NAME $
 $Release Date: PACKAGE RELEASE DATE $
 *****************************************************************************/

#ifndef L2CAP_H
#define L2CAP_H

#ifdef __cplusplus
extern "C"
{
#endif

/*********************************************************************
 * INCLUDES
 */
#include "bcomdef.h"
#include "osal.h"

/*********************************************************************
 * CONSTANTS
 */

#define L2CAP_MTU_SIZE                   23 


#define L2CAP_SDU_SIZE                   512 


#define L2CAP_NUM_PSM_DEFAULT            3 


#define L2CAP_NUM_CO_CHANNELS_DEFAULT    3 


// Minimum supported information payload for the Control frame (C-frame)
#define L2CAP_SIG_MTU_SIZE               23

// Basic L2CAP header: Length (2 bytes) + Channel ID (2 bytes)
#define L2CAP_HDR_SIZE                   4

// Minimum size of PDU received from lower layer protocol (incoming
// packet), or delivered to lower layer protocol (outgoing packet).
#define L2CAP_PDU_SIZE                   ( L2CAP_HDR_SIZE + L2CAP_MTU_SIZE )

// SDU Length field size
#define L2CAP_LEN_FIELD_SIZE             2
   
// LE Protocol/Service Multiplexer values. LE PSM values are separated into
// two ranges. Values in the first range are assigned by the Bluetooth SIG 
// and indicate protocols. Values in the second range are dynamically 
// allocated and used in conjunction with services defined in the GATT server.
#define L2CAP_INVALID_PSM                0x0000
  
// Fixed LE PSM values (assigned by Bluetooth SIG and indicate protocols)
#define L2CAP_FIXED_PSM_MIN              0x0001
#define L2CAP_FIXED_PSM_MAX              0x007F

// Dynamic LE PSM values (dynamically allocated and used in conjunction with GATT services)
#define L2CAP_DYNAMIC_PSM_MIN            0x0080
#define L2CAP_DYNAMIC_PSM_MAX            0x00FF
  
// L2CAP Channel Identifiers. Identifiers from 0x0001 to 0x003F are
// reserved for specific L2CAP functions. Identifiers 0x0001-0x0003
// are reserved by BR/EDR.
#define L2CAP_CID_NULL                   0x0000 // Illegal Identifier

// L2CAP Fixed Channel Identifiers
#define L2CAP_CID_ATT                    0x0004 // Attribute Protocol
#define L2CAP_CID_SIG                    0x0005 // L2CAP Signaling
#define L2CAP_CID_SMP                    0x0006 // Security Management Protocol
#define L2CAP_CID_GENERIC                0x0007 // Generic (proprietary channel)

// L2CAP Dynamic Channel Identifiers
#define L2CAP_DYNAMIC_CID_MIN            0x0040
#define L2CAP_DYNAMIC_CID_MAX            0x007F
    
// Number of Fixed channels: one for each of ATT, Signaling, SMP and Generic channels
#define L2CAP_NUM_FIXED_CHANNELS         4
  
// Number of Signaling Commands: one for Connection Parameter Update Request
#define L2CAP_NUM_SIG_COMMANDS           1

// L2CAP Response Timeout expired (RTX) value for Signaling commands (in seconds).
// The RTX timer is used for response timeout or to terminate a dynamic channel
// when the remote device is unresponsive to signaling requests. Its value may
// range from 1 to 60 seconds.
#define L2CAP_RTX_TIMEOUT                30

#define L2CAP_CMD_REJECT                 0x01 
#define L2CAP_DISCONNECT_REQ             0x06 
#define L2CAP_DISCONNECT_RSP             0x07 
#define L2CAP_INFO_REQ                   0x0a 
#define L2CAP_INFO_RSP                   0x0b 
#define L2CAP_PARAM_UPDATE_REQ           0x12 
#define L2CAP_PARAM_UPDATE_RSP           0x13 
#define L2CAP_CONNECT_REQ                0x14 
#define L2CAP_CONNECT_RSP                0x15 
#define L2CAP_FLOW_CTRL_CREDIT           0x16 


#define L2CAP_CHANNEL_ESTABLISHED_EVT    0x60 
#define L2CAP_CHANNEL_TERMINATED_EVT     0x61 
#define L2CAP_OUT_OF_CREDIT_EVT          0x62 
#define L2CAP_PEER_CREDIT_THRESHOLD_EVT  0x63 
#define L2CAP_SEND_SDU_DONE_EVT          0x64 
#define L2CAP_NUM_CTRL_DATA_PKT_EVT      0x65 


#define L2CAP_REJECT_CMD_NOT_UNDERSTOOD  0x0000 
#define L2CAP_REJECT_SIGNAL_MTU_EXCEED   0x0001 
#define L2CAP_REJECT_INVALID_CID         0x0002 


#define L2CAP_CONN_SUCCESS               0x0000 
#define L2CAP_CONN_PSM_NOT_SUPPORTED     0x0002 
#define L2CAP_CONN_NO_RESOURCES          0x0004 
#define L2CAP_CONN_INSUFFICIENT_AUTHEN   0x0005 
#define L2CAP_CONN_INSUFFICIENT_AUTHOR   0x0006 
#define L2CAP_CONN_INSUFFICIENT_KEY_SIZE 0x0007 
#define L2CAP_CONN_INSUFFICIENT_ENCRYPT  0x0008 

#define L2CAP_CONN_PENDING_SEC_VERIFY    0xFFFF 


#define L2CAP_CONN_PARAMS_ACCEPTED       0x0000 
#define L2CAP_CONN_PARAMS_REJECTED       0x0001 


#define L2CAP_TERM_LINK_DOWN             0x0000 
#define L2CAP_TERM_BY_PSM                0x0001 
#define L2CAP_TERM_BY_PEER_PSM           0x0002 
#define L2CAP_TERM_MAX_CREDIT_EXCEED     0x0003 
#define L2CAP_TERM_SDU_LEN_EXCEED        0x0004 
#define L2CAP_TERM_PSM_MTU_EXCEED        0x0005 
#define L2CAP_TERM_RX_PKT_NO_CREDIT      0x0006 
#define L2CAP_TERM_RX_ERROR              0x0007 
#define L2CAP_TERM_TX_ERROR              0x0008 
#define L2CAP_TERM_MEM_ALLOC_ERROR       0x0009 


#define L2CAP_CLOSED                     0x00 
#define L2CAP_OPEN                       0x01 
#define L2CAP_PENDING_CONN_RSP           0x02 
#define L2CAP_PENDING_DISCONN_RSP        0x03 
#define L2CAP_PENDING_PARAM_UPDATE_RSP   0x04 
#define L2CAP_PENDING_INFO_RSP           0x05 
#define L2CAP_PENDING_SEC_VERIFY         0x06 


#define L2CAP_INFO_CONNLESS_MTU          0x0001 
#define L2CAP_INFO_EXTENDED_FEATURES     0x0002 
#define L2CAP_INFO_FIXED_CHANNELS        0x0003 


/*********************************************************************
 * Information Response: Extended Features Mask Values
 */
  // Fixed channels are supported
#define L2CAP_FIXED_CHANNELS             0x00000080

  // Length of Extended Features bit mask
#define L2CAP_EXTENDED_FEATURES_SIZE     4

/*********************************************************************
 * Information Response: Fixed Channels Mask Values
 */
  // Fixed Channel ATT is supported
#define L2CAP_FIXED_CHANNELS_ATT         0x10

  // Fixed Channel L2CAP Signaling is supported
#define L2CAP_FIXED_CHANNELS_SIG         0x20

  // Fixed Channel SMP is supported
#define L2CAP_FIXED_CHANNELS_SMP         0x40

  // Length of Fixed Channels bit mask
#define L2CAP_FIXED_CHANNELS_SIZE        8

/*********************************************************************
 * Information Response: Result Values
 */
  // Success
#define L2CAP_INFO_SUCCESS               0x0000

  // Not supported
#define L2CAP_INFO_NOT_SUPPORTED         0x0001

/*********************************************************************
 * L2CAP Test Modes: Test code values
 */
#if defined ( TESTMODES )
  // Test modes 0 through 8 are reserved for L2CAP Connection Request.
  #define L2CAP_TESTMODE_OFF                  0  // Test mode off
  #define L2CAP_TESTMODE_PSM_NOT_SUPPORTED    2  // Refuse connection - LE_PSM not supported
  #define L2CAP_TESTMODE_NO_RESOURCES         4  // Refuse connection - no resources available
  #define L2CAP_TESTMODE_INSUFF_AUTHEN        5  // Refuse connection - insufficient authentication
  #define L2CAP_TESTMODE_INSUFF_AUTHOR        6  // Refuse connection - insufficient authorization
  #define L2CAP_TESTMODE_INSUFF_KEY_SIZE      7  // Refuse connection - insufficient encryption key size
  #define L2CAP_TESTMODE_INSUFF_ENCRYPT       8  // Refuse connection - insufficient encryption
  #define L2CAP_TESTMODE_OUT_OF_RANGE_CREDITS 9  // Allow out of range credits to be sent (0 or exceeding 65535)
  #define L2CAP_TESTMODE_SDU_LEN_EXCEED       10 // Send SDU larger than SDU length specified in first LE-frame of SDU
  #define L2CAP_TESTMODE_TX_PKT_NO_CREDIT     11 // Send LE-frame when local device has a credit count of zero
  #define L2CAP_TESTMODE_BLOCK_DATA_TX        12 // Block data packet transmission
#endif
  
/*********************************************************************
 * MACROS
 */

/*********************************************************************
 * TYPEDEFS
 */

typedef struct
{
  uint8 maxNumPSM;        
  uint8 maxNumCoChannels; 
} l2capUserCfg_t;

typedef struct
{
  uint16 localCID;  
  uint16 remoteCID; 
} l2capInvalidCID_t;

typedef union
{
  uint16 signalMTU;             
  l2capInvalidCID_t invalidCID; 
} l2capReasonData_t;

typedef struct
{
  uint16 reason;                
  l2capReasonData_t reasonData; 

  // Shorthand access for union members
  #define maxSignalMTU     reasonData.signalMTU
  #define invalidLocalCID  reasonData.invalidCID.localCID
  #define invalidRemoteCID reasonData.invalidCID.remoteCID
} l2capCmdReject_t;

typedef struct
{
  uint16 intervalMin;       
  uint16 intervalMax;       
  uint16 slaveLatency;      
  uint16 timeoutMultiplier; 
} l2capParamUpdateReq_t;

typedef struct
{
  uint16 result; 
} l2capParamUpdateRsp_t;

typedef struct
{
  uint16 infoType; 
} l2capInfoReq_t;

typedef union
{
  uint16 connectionlessMTU;                       
  uint32 extendedFeatures;                        
  uint8 fixedChannels[L2CAP_FIXED_CHANNELS_SIZE]; 
} l2capInfo_t;

typedef struct
{
  uint16 result;    
  uint16 infoType;  
  l2capInfo_t info; 
} l2capInfoRsp_t;

typedef struct
{
  uint16 psm;         
  uint16 srcCID;      
  uint16 mtu;         
  uint16 mps;         
  uint16 initCredits; 
} l2capConnectReq_t;

typedef struct
{
  uint16 dstCID;      
  uint16 mtu;         
  uint16 mps;         
  uint16 initCredits; 
  uint16 result;      
} l2capConnectRsp_t;

typedef struct
{
  uint16 dstCID; 
  uint16 srcCID; 
} l2capDisconnectReq_t;

typedef struct
{
  uint16 dstCID; 
  uint16 srcCID; 
} l2capDisconnectRsp_t;

typedef struct
{
  uint16 CID;     
  uint16 credits; 
} l2capFlowCtrlCredit_t;

typedef struct
{
  uint16 mtu;                 
  uint16 mps;                 
  uint16 initPeerCredits;     
  uint16 peerCreditThreshold; 
  uint8 maxNumChannels;       
  uint8 numActiveChannels;    
} l2capPsmInfo_t;

typedef struct
{
  uint16 psm;                 
  uint16 mtu;                 
  uint16 mps;                 
  uint16 credits;             
  uint16 peerCID;             
  uint16 peerMtu;             
  uint16 peerMps;             
  uint16 peerCredits;         
  uint16 peerCreditThreshold; 
} l2capCoCInfo_t;

typedef struct
{
  uint8 state;         
  l2capCoCInfo_t info; 
} l2capChannelInfo_t;

typedef struct
{
  uint16 result;       
  uint16 CID;          
  l2capCoCInfo_t info; 
} l2capChannelEstEvt_t;

typedef struct
{
  uint16 CID;     
  uint16 peerCID; 
  uint16 reason;  
} l2capChannelTermEvt_t;

typedef struct
{
  uint16 CID;     
  uint16 peerCID; 
  uint16 credits; 
} l2capCreditEvt_t;

typedef struct
{
  uint16 CID;         
  uint16 credits;     
  uint16 peerCID;     
  uint16 peerCredits; 
  uint16 totalLen;    
  uint16 txLen;       
} l2capSendSduDoneEvt_t;

typedef struct
{
  uint8 numDataPkt;   
} l2capNumCtrlDataPktEvt_t;

typedef union
{
  // Requests
  l2capParamUpdateReq_t updateReq;              
  l2capInfoReq_t infoReq;                       
  l2capConnectReq_t connectReq;                 
  l2capDisconnectReq_t disconnectReq;           
  l2capFlowCtrlCredit_t credit;                 
  
  // Responses
  l2capParamUpdateRsp_t updateRsp;              
  l2capInfoRsp_t infoRsp;                       
  l2capCmdReject_t cmdReject;                   
  l2capConnectRsp_t connectRsp;                 
  l2capDisconnectRsp_t disconnectRsp;           
  
  // Proprietary local events
  l2capChannelEstEvt_t channelEstEvt;           
  l2capChannelTermEvt_t channelTermEvt;         
  l2capCreditEvt_t creditEvt;                   
  l2capSendSduDoneEvt_t sendSduDoneEvt;         
  l2capNumCtrlDataPktEvt_t numCtrlDataPktEvt;       
} l2capSignalCmd_t;

typedef struct
{
  osal_event_hdr_t hdr; 
  uint16 connHandle;    
  uint8 id;             
  uint8 opcode;         
  l2capSignalCmd_t cmd; 
} l2capSignalEvent_t;

typedef struct
{
  uint16 CID;      
  uint8 *pPayload; 
  uint16 len;      
} l2capPacket_t;

typedef struct
{
  osal_event_hdr_t hdr; 
  uint16 connHandle;    
  l2capPacket_t pkt;    
} l2capDataEvent_t;

typedef uint16 (*pfnVerifySecCB_t)( uint16 connHandle, uint8 id, l2capConnectReq_t *pReq );

typedef struct
{
  uint16 psm;                      
  uint16 mtu;                      
  uint16 initPeerCredits;          
  uint16 peerCreditThreshold;      
  uint8 maxNumChannels;            
  uint8 taskId;                    
  pfnVerifySecCB_t pfnVerifySecCB; 
} l2capPsm_t;

/*********************************************************************
 * GLOBAL VARIABLES
 */

/*********************************************************************
 * FUNCTIONS
 */

extern bStatus_t L2CAP_RegisterApp( uint8 taskId, uint16 CID );

extern void L2CAP_RegisterFlowCtrlTask( uint8 taskId );

extern bStatus_t L2CAP_SendData( uint16 connHandle, l2capPacket_t *pPkt );

extern bStatus_t L2CAP_RegisterPsm( l2capPsm_t *pPsm );

extern bStatus_t L2CAP_DeregisterPsm( uint8 taskId, uint16 psm );

extern bStatus_t L2CAP_PsmInfo( uint16 psm, l2capPsmInfo_t *pInfo );

extern bStatus_t L2CAP_PsmChannels( uint16 psm, uint8 numCIDs, uint16 *pCIDs );

extern bStatus_t L2CAP_ChannelInfo( uint16 CID, l2capChannelInfo_t *pInfo );

extern bStatus_t L2CAP_ConnectReq( uint16 connHandle, uint16 psm, uint16 peerPsm );

extern bStatus_t L2CAP_ConnectRsp( uint16 connHandle, uint8 id, uint16 result );

extern bStatus_t L2CAP_DisconnectReq( uint16 CID );

extern bStatus_t L2CAP_FlowCtrlCredit( uint16 CID, uint16 peerCredits );

extern bStatus_t L2CAP_SendSDU( l2capPacket_t *pPkt );

extern bStatus_t L2CAP_CmdReject( uint16 connHandle, uint8 id, l2capCmdReject_t *pCmdReject );

extern bStatus_t L2CAP_InfoReq( uint16 connHandle, l2capInfoReq_t *pInfoReq, uint8 taskId );

extern bStatus_t L2CAP_ConnParamUpdateReq( uint16 connHandle, l2capParamUpdateReq_t *pUpdateReq, uint8 taskId );

extern bStatus_t L2CAP_ConnParamUpdateRsp( uint16 connHandle, uint8 id, l2capParamUpdateRsp_t *pUpdateRsp );

extern void L2CAP_SetUserConfig( l2capUserCfg_t *pUserCfg );

extern void L2CAP_SetBufSize( uint16 dataPktLen, uint8 numDataPkts );

extern uint16 L2CAP_GetMTU( void );

extern void *L2CAP_bm_alloc( uint16 size );

extern uint16 L2CAP_BuildConnectReq( uint8 *pBuf, uint8 *pData );

extern bStatus_t L2CAP_ParseConnectReq( l2capSignalCmd_t *pCmd, uint8 *pData, uint16 len );

extern bStatus_t L2CAP_ParseFlowCtrlCredit( l2capSignalCmd_t *pCmd, uint8 *pData, uint16 len );

extern uint16 L2CAP_BuildCmdReject( uint8 *pBuf, uint8 *pCmd );

extern bStatus_t L2CAP_ParseInfoReq( l2capSignalCmd_t *pCmd, uint8 *pData, uint16 len );

extern bStatus_t L2CAP_ParseParamUpdateReq( l2capSignalCmd_t *pCmd, uint8 *pData, uint16 len );

extern uint16 L2CAP_BuildParamUpdateRsp( uint8 *pBuf, uint8 *pData );

extern uint16 L2CAP_BuildInfoRsp( uint8 *pBuf, uint8 *pData );

extern void L2CAP_SetControllerToHostFlowCtrl( uint16 hostBuffSize, uint8 flowCtrlMode );

extern void L2CAP_HostNumCompletedPkts( uint16 connHandle, uint16 numCompletedPkts );

extern void L2CAP_SetParamValue( uint16 value );

extern uint16 L2CAP_GetParamValue( void );

/*-------------------------------------------------------------------
 * TASK API - These functions must only be called by OSAL.
 */

extern void L2CAP_Init( uint8 taskId );

extern uint16 L2CAP_ProcessEvent( uint8 taskId, uint16 events );


/*********************************************************************
*********************************************************************/

#ifdef __cplusplus
}
#endif

#endif /* L2CAP_H */