pinebuds/services/bt_if_enhanced/inc/bluetooth.h

444 lines
13 KiB
C
Raw Normal View History

2022-08-15 04:20:27 -05:00
/***************************************************************************
*
* Copyright 2015-2019 BES.
* All rights reserved. All unpublished rights reserved.
*
* No part of this work may be used or reproduced in any form or by any
* means, or stored in a database or retrieval system, without prior written
* permission of BES.
*
* Use of this work is governed by a license granted by BES.
* This work contains confidential and proprietary information of
* BES. which is protected by copyright, trade secret,
* trademark and other intellectual property rights.
*
****************************************************************************/
#ifndef __BLUETOOTH_H__
#define __BLUETOOTH_H__
#include "stdint.h"
#include "string.h"
#include "btif_sys_config.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifndef BOOL_DEFINED
typedef unsigned int BOOL; /* IGNORESTYLE */
#endif
typedef unsigned int U32;
typedef unsigned short U16;
typedef unsigned char U8;
typedef int S32;
typedef short S16;
typedef char S8;
#ifndef U32_PTR_DEFINED
typedef U32 U32_PTR;
#define U32_PTR_DEFINED
#endif /* U32_PTR_DEFINED */
/* Variable sized integers. Used to optimize processor efficiency by
* using the most efficient data size for counters, arithmatic, etc.
*/
typedef unsigned long I32;
#ifndef XA_INTEGER_SIZE
#define XA_INTEGER_SIZE 4
#endif
#if XA_INTEGER_SIZE == 4
typedef unsigned long I16;
typedef unsigned long I8;
#elif XA_INTEGER_SIZE == 2
typedef unsigned short I16;
typedef unsigned short I8;
#elif XA_INTEGER_SIZE == 1
typedef unsigned short I16;
typedef unsigned char I8;
#else
#error No XA_INTEGER_SIZE specified!
#endif
typedef void (*PFV) (void);
/* Boolean Definitions */
#ifndef TRUE
#define TRUE (1==1)
#endif /* TRUE */
#ifndef FALSE
#define FALSE (0==1)
#endif /* FALSE */
#ifndef TimeT
typedef U32 TimeT;
#endif
#ifndef BtPriority
typedef U8 BtPriority;
#endif
/** Bluetooth Address */
typedef struct {
uint8_t address[6];
} __attribute__ ((packed)) bt_bdaddr_t;
#define BTIF_BD_ADDR_SIZE 6
#define BTIF_LINK_KEY_SIZE 16
typedef struct _list_entr {
struct _list_entr *Flink;
struct _list_entr *Blink;
unsigned int resv;
} list_entry_t;
/*---------------------------------------------------------------------------
*
* Doubly-linked list manipulation routines. Some are implemented as
* macros but logically are procedures.
*/
#ifndef BTIF_LIST_MACROS
//void InitializeListHead(ListEntry *head);
#define initialize_list_head(ListHead) (\
(ListHead)->Flink = (ListHead)->Blink = (ListHead) )
#define initialize_list_entry(Entry) (\
(Entry)->Flink = (Entry)->Blink = 0 )
#define is_entry_available(Entry) (\
((Entry)->Flink == 0))
#ifndef is_list_empty
//BOOL is_list_empty(ListEntry *head);
#define is_list_empty(ListHead) (\
((ListHead)->Flink == (ListHead)))
#endif
#define get_head_list(ListHead) (ListHead)->Flink
#define get_tail_list(ListHead) (ListHead)->Blink
#define get_next_node(Node) (Node)->Flink
#define get_prior_node(Node) (Node)->Blink
#define is_node_connected(n) (((n)->Blink->Flink == (n)) && ((n)->Flink->Blink == (n)))
BOOL is_list_circular(list_entry_t * list);
#define list_assert(exp) (ASSERT(exp, "%s %s, %d\n", #exp, __func__, __LINE__))
//void InsertTailList(ListEntry *head, ListEntry *entry);
void _insert_tail_list(list_entry_t * head, list_entry_t * entry);
#define insert_tail_list(a, b) (list_assert(is_list_circular(a)), \
_insert_tail_list(a, b), \
list_assert(is_list_circular(a)))
void insert_head_list(list_entry_t * head, list_entry_t * entry);
void _insert_head_list(list_entry_t * head, list_entry_t * entry);
#define insert_head_list(a, b) (list_assert(is_list_circular(a)), \
_insert_head_list(a, b), \
list_assert(is_list_circular(a)))
list_entry_t *remove_head_list(list_entry_t * head);
list_entry_t *_remove_head_list(list_entry_t * head);
#define remove_head_list(a) (list_assert(is_list_circular(a)), \
_remove_head_list(a))
void remove_entry_list(list_entry_t * entry);
BOOL is_node_on_list(list_entry_t * head, list_entry_t * node);
U8 get_list_number(list_entry_t * head);
BOOL is_list_circular(list_entry_t * list);
void move_list(list_entry_t * dest, list_entry_t * src);
#endif
#define iterate_list_safe(head, cur, next, type) \
for ( (cur) = (type) get_head_list(head) ; \
(next) = (type) get_next_node(&(cur)->node), \
(cur) != (type) (head); \
(cur) = (next))
/*---------------------------------------------------------------------------
* IterateList()
*
* Sets up ordinary traversal of a list. The current member must NOT
* be removed during iteration. Must be followed by a block of code
* containing the body of the iteration.
*
* For example:
* BtSecurityRecord *record;
* IterateList(MEC(secList), record, BtSecurityRecord *) {
* [...do something with "record", but do not remove it!...]
* }
*
* Parameters:
* head - Head of list (address of ListEntry structure)
* cur - Variable to use for current list member
* type - Structure type of cur and next.
*/
#define iterate_list(head, cur, type) \
for ( (cur) = (type) get_head_list(&(head)) ; \
(cur) != (type) &(head); \
(cur) = (type) get_next_node(&(cur)->node) )
enum _bt_status {
BT_STS_SUCCESS = 0,
BT_STS_FAILED = 1,
BT_STS_PENDING = 2,
BT_STS_BUSY = 11,
BT_STS_NO_RESOURCES = 12,
BT_STS_NOT_FOUND = 13,
BT_STS_DEVICE_NOT_FOUND = 14,
BT_STS_CONNECTION_FAILED = 15,
BT_STS_TIMEOUT = 16,
BT_STS_NO_CONNECTION = 17,
BT_STS_INVALID_PARM = 18,
BT_STS_IN_PROGRESS = 19,
BT_STS_RESTRICTED = 20,
BT_STS_INVALID_TYPE = 21,
BT_STS_HCI_INIT_ERR = 22,
BT_STS_NOT_SUPPORTED = 23,
BT_STS_IN_USE = 5,
BT_STS_SDP_CONT_STATE = 24,
BT_STS_CONTINUE =24,
BT_STS_CANCELLED = 25,
/* The last defined status code */
BT_STS_LAST_CODE = BT_STS_CANCELLED,
};
typedef uint32_t bt_status_t;
typedef struct _evm_timer evm_timer_t;
typedef void (*evm_timer_notify) (evm_timer_t *);
struct _evm_timer {
list_entry_t node; /* Used internally by the Event Manager */
void *context; /* Context area for use by callers */
evm_timer_notify func; /* Function to call when timer fires */
/* === Internal use only === */
TimeT time; /* Amount of time to wait */
TimeT startTime; /* System time when the timer started */
};
/*---------------------------------------------------------------------------
* btif_packet_flags type
*
* This type is used by L2CAP and protocols that use directly L2CAP
* to manage the status of a particular BtPacket.
*/
typedef uint16_t btif_packet_flags;
#define BTIF_BTP_FLAG_NONE 0x0000 /* No current flags */
#define BTIF_BTP_FLAG_INUSE 0x0001 /* Used only by packet owner */
#define BTIF_BTP_FLAG_LSYSTEM 0x0002 /* Used only by L2CAP */
#define BTIF_BTP_FLAG_TAIL 0x0004 /* Used only by L2CAP Applications */
#define BTIF_BTP_FLAG_RDEV 0x0008 /* Used only by L2CAP */
#define BTIF_BTP_FLAG_FCS 0x0010 /* FCS field is valid, set only by L2CAP */
#define BTIF_BTP_FLAG_NON_FLUSH 0x0020 /* Used by L2CAP, HCI or packet owner */
#define BTIF_BTP_FLAG_ENHANCED 0x0040 /* Used only by L2CAP */
#define BTIF_BTP_FLAG_SEGMENTED 0x0080 /* Used only by L2CAP */
#define BTIF_BTP_FLAG_TXDONE 0x0100 /* Used only by L2CAP */
#define BTIF_BTP_FLAG_USER 0x0200 /* Used only by L2CAP */
#define BTIF_BTP_FLAG_IMMEDIATE 0x0400 /* Used only by L2CAP */
/* End of btif_packet_flags */
#define BTIF_BT_PACKET_HEADER_LEN 25
typedef struct {
list_entry_t node;
uint8_t *data; /* Points to a buffer of user data. */
uint16_t dataLen; /* Indicates the length of "data" in bytes. */
uint16_t flags; /* Must be initialized to BTIF_BTP_FLAG_NONE by
* applications running on top of L2CAP.
*/
#if BTIF_L2CAP_PRIORITY == BTIF_ENABLED
BtPriority priority;
#endif
/* Group: The following fields are for internal use only by the stack. */
void *ulpContext;
uint8_t *tail;
uint16_t tailLen;
#ifdef BTIF_XA_STATISTICS
U32 rfc_timer;
U32 hci_timer;
U32 l2cap_timer;
#endif
uint16_t llpContext;
uint16_t remoteCid;
#if BTIF_L2CAP_NUM_ENHANCED_CHANNELS > 0
uint8_t segStart;
uint16_t segNum;
uint16_t segCount;
uint8_t fcs[2];
#endif
uint8_t hciPackets;
uint8_t headerLen;
uint8_t header[BTIF_BT_PACKET_HEADER_LEN];
} btif_bt_packet_t;
/*---------------------------------------------------------------------------
* le_to_host16()
*---------------------------------------------------------------------------
*
* Synopsis: Retrieve a 16-bit number from the given buffer. The number
* is in Little-Endian format.
*
* Return: 16-bit number.
*/
U16 le_to_host16(const U8 * ptr);
/*---------------------------------------------------------------------------
* be_to_host16()
*---------------------------------------------------------------------------
*
* Synopsis: Retrieve a 16-bit number from the given buffer. The number
* is in Big-Endian format.
*
* Return: 16-bit number.
*/
U16 be_to_host16(const U8* ptr);
/*---------------------------------------------------------------------------
* be_to_host32()
*---------------------------------------------------------------------------
*
* Synopsis: Retrieve a 32-bit number from the given buffer. The number
* is in Big-Endian format.
*
* Return: 32-bit number.
*/
U32 be_to_host32(const U8* ptr);
/*---------------------------------------------------------------------------
* store_le16()
*---------------------------------------------------------------------------
*
* Synopsis: Store 16 bit value into a buffer in Little Endian format.
*
* Return: void
*/
void store_le16(U8 *buff, U16 le_value);
/*---------------------------------------------------------------------------
* store_le32()
*---------------------------------------------------------------------------
*
* Synopsis: Store 32 bit value into a buffer in Little Endian format.
*
* Return: void
*/
void store_le32(U8 *buff, U32 le_value);
/*---------------------------------------------------------------------------
* store_be16()
*---------------------------------------------------------------------------
*
* Synopsis: Store 16 bit value into a buffer in Big Endian format.
*
* Return: void
*/
void store_be16(U8 *buff, U16 be_value);
/*---------------------------------------------------------------------------
* store_be32()
*---------------------------------------------------------------------------
*
* Synopsis: Store 32 bit value into a buffer in Big Endian format.
*
* Return: void
*/
void store_be32(U8 *buff, U32 be_value);
#if defined(ENHANCED_STACK)
/* Copy, compare bluetooth Address */
static inline int ba_cmp(const bt_bdaddr_t *ba1, const bt_bdaddr_t *ba2)
{
return memcmp(ba1, ba2, sizeof(bt_bdaddr_t ));
}
static inline void ba_cpy( bt_bdaddr_t *dst, const bt_bdaddr_t *src)
{
memcpy(dst, src, sizeof(bt_bdaddr_t ));
}
#define BTIF_CTX_INIT(buff) \
POSSIBLY_UNUSED unsigned int __offset = 2; \
POSSIBLY_UNUSED unsigned char *__buff = buff;
#define BTIF_CTX_STR_BUF(buff,len) \
memcpy(__buff+__offset, buff, len); \
__offset += len;
#define BTIF_CTX_LDR_BUF(buff,len) \
memcpy(buff, __buff+__offset, len); \
__offset += len;
#define BTIF_CTX_STR_VAL8(v) \
__buff[__offset] = v&0xFF; \
__offset += 1;
#define BTIF_CTX_LDR_VAL8(v) \
v = __buff[__offset]; \
__offset += 1;
#define BTIF_CTX_STR_VAL16(v) \
__buff[__offset] = v&0xFF; \
__buff[__offset+1] = (v>>8)&0xFF; \
__offset += 2;
#define BTIF_CTX_LDR_VAL16(v) \
v = __buff[__offset]; \
v |= __buff[__offset+1]<<8; \
__offset += 2;
#define BTIF_CTX_STR_VAL32(v) \
__buff[__offset] = v&0xFF; \
__buff[__offset+1] = (v>>8)&0xFF; \
__buff[__offset+2] = (v>>16)&0xFF; \
__buff[__offset+3] = (v>>24)&0xFF; \
__offset += 4;
#define BTIF_CTX_LDR_VAL32(v) \
v = __buff[__offset]; \
v |= __buff[__offset+1]<<8; \
v |= __buff[__offset+2]<<16; \
v |= __buff[__offset+3]<<24; \
__offset += 4;
#define BTIF_CTX_GET_BUF_CURR() __buff
#define BTIF_CTX_GET_BUF_HEAD() __buff
#define BTIF_CTX_GET_OFFSET() __offset
#define BTIF_CTX_GET_DATA_LEN() (__buff[0] | __buff[1]<<8)
#define BTIF_CTX_GET_TOTAL_LEN() (BTIF_CTX_GET_DATA_LEN()+2)
#define BTIF_CTX_SAVE_UPDATE_DATA_LEN() \
__buff[0] = (__offset-2)&0xFF; \
__buff[1] = ((__offset-2)>>8)&0xFF;
struct btif_ctx_content {
unsigned char *buff;
unsigned int buff_len;
};
#endif /* ENHANCED_STACK */
#ifdef __cplusplus
}
#endif /* */
#endif /*__BLUETOOTH_H__*/