xref: /btstack/src/hci.h (revision 2cc827d4920e09c7219a79fceb0577d37efd4025)
1 /*
2  * Copyright (C) 2014 BlueKitchen GmbH
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the copyright holders nor the names of
14  *    contributors may be used to endorse or promote products derived
15  *    from this software without specific prior written permission.
16  * 4. Any redistribution, use, or modification is done solely for
17  *    personal benefit and not for any commercial purpose or for
18  *    monetary gain.
19  *
20  * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS
24  * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
27  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
30  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * Please inquire about commercial licensing options at
34  * [email protected]
35  *
36  */
37 
38 /*
39  *  hci.h
40  *
41  *  Created by Matthias Ringwald on 4/29/09.
42  *
43  */
44 
45 #ifndef HCI_H
46 #define HCI_H
47 
48 #include "btstack_config.h"
49 
50 #include "btstack_chipset.h"
51 #include "btstack_control.h"
52 #include "btstack_linked_list.h"
53 #include "btstack_util.h"
54 #include "classic/btstack_link_key_db.h"
55 #include "hci_cmd.h"
56 #include "gap.h"
57 #include "hci_transport.h"
58 #include "btstack_run_loop.h"
59 
60 #ifdef ENABLE_BLE
61 #include "ble/att_db.h"
62 #endif
63 
64 #include <stdint.h>
65 #include <stdlib.h>
66 #include <stdarg.h>
67 
68 #if defined __cplusplus
69 extern "C" {
70 #endif
71 
72 // packet buffer sizes
73 #define HCI_CMD_HEADER_SIZE          3
74 #define HCI_ACL_HEADER_SIZE          4
75 #define HCI_SCO_HEADER_SIZE          3
76 #define HCI_EVENT_HEADER_SIZE        2
77 
78 #define HCI_EVENT_PAYLOAD_SIZE     255
79 #define HCI_CMD_PAYLOAD_SIZE       255
80 
81 // Max HCI Command LE payload size:
82 // 64 from LE Generate DHKey command
83 // 32 from LE Encrypt command
84 #if defined(ENABLE_LE_SECURE_CONNECTIONS) && !defined(ENABLE_MICRO_ECC_FOR_LE_SECURE_CONNECTIONS)
85 #define HCI_CMD_PAYLOAD_SIZE_LE 64
86 #else
87 #define HCI_CMD_PAYLOAD_SIZE_LE 32
88 #endif
89 
90 // HCI_ACL_PAYLOAD_SIZE is configurable and defined in config.h
91 // addition byte in even to terminate remote name request with '\0'
92 #define HCI_EVENT_BUFFER_SIZE      (HCI_EVENT_HEADER_SIZE + HCI_EVENT_PAYLOAD_SIZE + 1)
93 
94 #ifdef ENABLE_CLASSIC
95 #define HCI_CMD_BUFFER_SIZE        (HCI_CMD_HEADER_SIZE   + HCI_CMD_PAYLOAD_SIZE)
96 #else
97 #define HCI_CMD_BUFFER_SIZE        (HCI_CMD_HEADER_SIZE   + HCI_CMD_PAYLOAD_SIZE_LE)
98 #endif
99 
100 #define HCI_ACL_BUFFER_SIZE        (HCI_ACL_HEADER_SIZE   + HCI_ACL_PAYLOAD_SIZE)
101 
102 // size of hci incoming buffer, big enough for event or acl packet without H4 packet type
103 #ifdef HCI_INCOMING_PACKET_BUFFER_SIZE
104     #if HCI_INCOMING_PACKET_BUFFER_SIZE < HCI_ACL_BUFFER_SIZE
105         #error HCI_INCOMING_PACKET_BUFFER_SIZE must be equal or larger than HCI_ACL_BUFFER_SIZE
106     #endif
107     #if HCI_INCOMING_PACKET_BUFFER_SIZE < HCI_EVENT_BUFFER_SIZE
108         #error HCI_INCOMING_PACKET_BUFFER_SIZE must be equal or larger than HCI_EVENT_BUFFER_SIZE
109     #endif
110 #else
111     #if HCI_ACL_BUFFER_SIZE > HCI_EVENT_BUFFER_SIZE
112         #define HCI_INCOMING_PACKET_BUFFER_SIZE HCI_ACL_BUFFER_SIZE
113     #else
114         #define HCI_INCOMING_PACKET_BUFFER_SIZE HCI_EVENT_BUFFER_SIZE
115     #endif
116 #endif
117 
118 // size of hci outgoing buffer, big enough for command or acl packet without H4 packet type
119 #ifdef HCI_OUTGOING_PACKET_BUFFER_SIZE
120     #if HCI_OUTGOING_PACKET_BUFFER_SIZE < HCI_ACL_BUFFER_SIZE
121         #error HCI_OUTGOING_PACKET_BUFFER_SIZE must be equal or larger than HCI_ACL_BUFFER_SIZE
122     #endif
123     #if HCI_OUTGOING_PACKET_BUFFER_SIZE < HCI_CMD_BUFFER_SIZE
124         #error HCI_OUTGOING_PACKET_BUFFER_SIZE must be equal or larger than HCI_CMD_BUFFER_SIZE
125     #endif
126 #else
127     #if HCI_ACL_BUFFER_SIZE > HCI_CMD_BUFFER_SIZE
128         #define HCI_OUTGOING_PACKET_BUFFER_SIZE HCI_ACL_BUFFER_SIZE
129     #else
130         #define HCI_OUTGOING_PACKET_BUFFER_SIZE HCI_CMD_BUFFER_SIZE
131     #endif
132 #endif
133 
134 // additional pre-buffer space for packets to Bluetooth module, for now, used for HCI Transport H4 DMA
135 #ifndef HCI_OUTGOING_PRE_BUFFER_SIZE
136 #ifdef HAVE_HOST_CONTROLLER_API
137 #define HCI_OUTGOING_PRE_BUFFER_SIZE 0
138 #else
139 #define HCI_OUTGOING_PRE_BUFFER_SIZE 1
140 #endif
141 #endif
142 
143 // BNEP may uncompress the IP Header by 16 bytes, GATT Client requires two additional bytes for long characteristic reads
144 #ifndef HCI_INCOMING_PRE_BUFFER_SIZE
145 #ifdef ENABLE_CLASSIC
146 #define HCI_INCOMING_PRE_BUFFER_SIZE (16 - HCI_ACL_HEADER_SIZE - 4)
147 #else
148 #define HCI_INCOMING_PRE_BUFFER_SIZE 2
149 #endif
150 #endif
151 
152 //
153 #define IS_COMMAND(packet, command) ( little_endian_read_16(packet,0) == command.opcode )
154 
155 // check if command complete event for given command
156 #define HCI_EVENT_IS_COMMAND_COMPLETE(event,cmd) ( (event[0] == HCI_EVENT_COMMAND_COMPLETE) && (little_endian_read_16(event,3) == cmd.opcode) )
157 #define HCI_EVENT_IS_COMMAND_STATUS(event,cmd)   ( (event[0] == HCI_EVENT_COMMAND_STATUS)   && (little_endian_read_16(event,4) == cmd.opcode) )
158 
159 // Code+Len=2, Pkts+Opcode=3; total=5
160 #define OFFSET_OF_DATA_IN_COMMAND_COMPLETE 5
161 
162 // ACL Packet
163 #define READ_ACL_CONNECTION_HANDLE( buffer ) ( little_endian_read_16(buffer,0) & 0x0fff)
164 #define READ_SCO_CONNECTION_HANDLE( buffer ) ( little_endian_read_16(buffer,0) & 0x0fff)
165 #define READ_ACL_FLAGS( buffer )      ( buffer[1] >> 4 )
166 #define READ_ACL_LENGTH( buffer )     (little_endian_read_16(buffer, 2))
167 
168 // Sneak peak into L2CAP Packet
169 #define READ_L2CAP_LENGTH(buffer)     ( little_endian_read_16(buffer, 4))
170 #define READ_L2CAP_CHANNEL_ID(buffer) ( little_endian_read_16(buffer, 6))
171 
172 /**
173  * LE connection parameter update state
174  */
175 
176 typedef enum {
177     CON_PARAMETER_UPDATE_NONE,
178     // L2CAP
179     CON_PARAMETER_UPDATE_SEND_REQUEST,
180     CON_PARAMETER_UPDATE_SEND_RESPONSE,
181     CON_PARAMETER_UPDATE_CHANGE_HCI_CON_PARAMETERS,
182     CON_PARAMETER_UPDATE_DENY,
183     // HCI - in respnose to HCI_SUBEVENT_LE_REMOTE_CONNECTION_PARAMETER_REQUEST
184     CON_PARAMETER_UPDATE_REPLY,
185     CON_PARAMETER_UPDATE_NEGATIVE_REPLY,
186 } le_con_parameter_update_state_t;
187 
188 // Authentication flags
189 typedef enum {
190     AUTH_FLAGS_NONE                = 0x0000,
191     RECV_LINK_KEY_REQUEST          = 0x0001,
192     HANDLE_LINK_KEY_REQUEST        = 0x0002,
193     SENT_LINK_KEY_REPLY            = 0x0004,
194     SENT_LINK_KEY_NEGATIVE_REQUEST = 0x0008,
195     RECV_LINK_KEY_NOTIFICATION     = 0x0010,
196     DENY_PIN_CODE_REQUEST          = 0x0040,
197     RECV_IO_CAPABILITIES_REQUEST   = 0x0080,
198     SEND_IO_CAPABILITIES_REPLY     = 0x0100,
199     SEND_IO_CAPABILITIES_NEGATIVE_REPLY = 0x0200,
200     SEND_USER_CONFIRM_REPLY        = 0x0400,
201     SEND_USER_PASSKEY_REPLY        = 0x0800,
202 
203     // Classic OOB
204     SEND_REMOTE_OOB_DATA_REPLY     = 0x1800,
205 
206     // pairing status
207     LEGACY_PAIRING_ACTIVE          = 0x2000,
208     SSP_PAIRING_ACTIVE             = 0x4000,
209 
210     // connection status
211     CONNECTION_AUTHENTICATED       = 0x8000,
212     CONNECTION_ENCRYPTED           = 0x10000,
213 
214     // errands
215     READ_RSSI                      = 0x20000,
216     WRITE_SUPERVISION_TIMEOUT      = 0x40000,
217 
218 } hci_authentication_flags_t;
219 
220 /**
221  * Connection State
222  */
223 typedef enum {
224     SEND_CREATE_CONNECTION = 0,
225     SENT_CREATE_CONNECTION,
226     SEND_CANCEL_CONNECTION,
227     SENT_CANCEL_CONNECTION,
228     RECEIVED_CONNECTION_REQUEST,
229     ACCEPTED_CONNECTION_REQUEST,
230     REJECTED_CONNECTION_REQUEST,
231     OPEN,
232     SEND_DISCONNECT,
233     SENT_DISCONNECT,
234     RECEIVED_DISCONNECTION_COMPLETE
235 } CONNECTION_STATE;
236 
237 // bonding flags
238 enum {
239     BONDING_REQUEST_REMOTE_FEATURES_PAGE_0    = 0x0001,
240     BONDING_REQUEST_REMOTE_FEATURES_PAGE_1    = 0x0002,
241     BONDING_REQUEST_REMOTE_FEATURES_PAGE_2    = 0x0004,
242     BONDING_RECEIVED_REMOTE_FEATURES          = 0x0008,
243     BONDING_REMOTE_SUPPORTS_SSP_CONTROLLER    = 0x0010,
244     BONDING_REMOTE_SUPPORTS_SSP_HOST          = 0x0020,
245     BONDING_REMOTE_SUPPORTS_SC_CONTROLLER     = 0x0040,
246     BONDING_REMOTE_SUPPORTS_SC_HOST           = 0x0080,
247     BONDING_DISCONNECT_SECURITY_BLOCK         = 0x0100,
248     BONDING_DISCONNECT_DEDICATED_DONE         = 0x0200,
249     BONDING_SEND_AUTHENTICATE_REQUEST         = 0x0400,
250     BONDING_SEND_ENCRYPTION_REQUEST           = 0x0800,
251     BONDING_SEND_READ_ENCRYPTION_KEY_SIZE     = 0x1000,
252     BONDING_DEDICATED                         = 0x2000,
253     BONDING_EMIT_COMPLETE_ON_DISCONNECT       = 0x4000,
254     BONDING_SENT_AUTHENTICATE_REQUEST         = 0x8000
255 };
256 
257 typedef enum {
258     BLUETOOTH_OFF = 1,
259     BLUETOOTH_ON,
260     BLUETOOTH_ACTIVE
261 } BLUETOOTH_STATE;
262 
263 typedef enum {
264     LE_CONNECTING_IDLE,
265     LE_CONNECTING_CANCEL,
266     LE_CONNECTING_DIRECT,
267     LE_CONNECTING_WHITELIST,
268 } le_connecting_state_t;
269 
270 #ifdef ENABLE_BLE
271 
272 //
273 // SM internal types and globals
274 //
275 
276 typedef enum {
277 
278     // general states
279     SM_GENERAL_IDLE,
280     SM_GENERAL_SEND_PAIRING_FAILED,
281     SM_GENERAL_TIMEOUT, // no other security messages are exchanged
282     SM_GENERAL_REENCRYPTION_FAILED,
283 
284     // Phase 1: Pairing Feature Exchange
285     SM_PH1_W4_USER_RESPONSE,
286 
287     // Phase 2: Authenticating and Encrypting
288 
289     // get random number for use as TK Passkey if we show it
290     SM_PH2_GET_RANDOM_TK,
291     SM_PH2_W4_RANDOM_TK,
292 
293     // get local random number for confirm c1
294     SM_PH2_C1_GET_RANDOM_A,
295     SM_PH2_C1_W4_RANDOM_A,
296     SM_PH2_C1_GET_RANDOM_B,
297     SM_PH2_C1_W4_RANDOM_B,
298 
299     // calculate confirm value for local side
300     SM_PH2_C1_GET_ENC_A,
301     SM_PH2_C1_W4_ENC_A,
302 
303     // calculate confirm value for remote side
304     SM_PH2_C1_GET_ENC_C,
305     SM_PH2_C1_W4_ENC_C,
306 
307     SM_PH2_C1_SEND_PAIRING_CONFIRM,
308     SM_PH2_SEND_PAIRING_RANDOM,
309 
310     // calc STK
311     SM_PH2_CALC_STK,
312     SM_PH2_W4_STK,
313 
314     SM_PH2_W4_CONNECTION_ENCRYPTED,
315 
316     // Phase 3: Transport Specific Key Distribution
317     // calculate DHK, Y, EDIV, and LTK
318     SM_PH3_Y_GET_ENC,
319     SM_PH3_Y_W4_ENC,
320     SM_PH3_LTK_GET_ENC,
321 
322     // exchange keys
323     SM_PH3_DISTRIBUTE_KEYS,
324     SM_PH3_RECEIVE_KEYS,
325 
326     // Phase 4: re-establish previously distributed LTK
327     SM_PH4_W4_CONNECTION_ENCRYPTED,
328 
329     // RESPONDER ROLE
330     SM_RESPONDER_IDLE,
331     SM_RESPONDER_SEND_SECURITY_REQUEST,
332     SM_RESPONDER_PH0_RECEIVED_LTK_REQUEST,
333     SM_RESPONDER_PH0_RECEIVED_LTK_W4_IRK,
334     SM_RESPONDER_PH0_SEND_LTK_REQUESTED_NEGATIVE_REPLY,
335     SM_RESPONDER_PH1_W4_PAIRING_REQUEST,
336     SM_RESPONDER_PH1_PAIRING_REQUEST_RECEIVED,
337     SM_RESPONDER_PH1_PAIRING_REQUEST_RECEIVED_W4_IRK,
338     SM_RESPONDER_PH1_SEND_PAIRING_RESPONSE,
339     SM_RESPONDER_PH1_W4_PAIRING_CONFIRM,
340     SM_RESPONDER_PH2_W4_PAIRING_RANDOM,
341     SM_RESPONDER_PH2_W4_LTK_REQUEST,
342     SM_RESPONDER_PH2_SEND_LTK_REPLY,
343     SM_RESPONDER_PH4_Y_W4_ENC,
344     SM_RESPONDER_PH4_SEND_LTK_REPLY,
345 
346     // INITIATOR ROLE
347     SM_INITIATOR_CONNECTED,
348     SM_INITIATOR_PH1_W2_SEND_PAIRING_REQUEST,
349     SM_INITIATOR_PH1_W4_PAIRING_RESPONSE,
350     SM_INITIATOR_PH2_W4_PAIRING_CONFIRM,
351     SM_INITIATOR_PH2_W4_PAIRING_RANDOM,
352     SM_INITIATOR_PH3_SEND_START_ENCRYPTION,
353     SM_INITIATOR_PH4_HAS_LTK,
354 
355     // LE Secure Connections
356     SM_SC_RECEIVED_LTK_REQUEST,
357     SM_SC_SEND_PUBLIC_KEY_COMMAND,
358     SM_SC_W4_PUBLIC_KEY_COMMAND,
359     SM_SC_W4_LOCAL_NONCE,
360     SM_SC_W2_CMAC_FOR_CONFIRMATION,
361     SM_SC_W4_CMAC_FOR_CONFIRMATION,
362     SM_SC_SEND_CONFIRMATION,
363     SM_SC_W2_CMAC_FOR_CHECK_CONFIRMATION,
364     SM_SC_W4_CMAC_FOR_CHECK_CONFIRMATION,
365     SM_SC_W4_CONFIRMATION,
366     SM_SC_SEND_PAIRING_RANDOM,
367     SM_SC_W4_PAIRING_RANDOM,
368     SM_SC_W2_CALCULATE_G2,
369     SM_SC_W4_CALCULATE_G2,
370     SM_SC_W4_CALCULATE_DHKEY,
371     SM_SC_W2_CALCULATE_F5_SALT,
372     SM_SC_W4_CALCULATE_F5_SALT,
373     SM_SC_W2_CALCULATE_F5_MACKEY,
374     SM_SC_W4_CALCULATE_F5_MACKEY,
375     SM_SC_W2_CALCULATE_F5_LTK,
376     SM_SC_W4_CALCULATE_F5_LTK,
377     SM_SC_W2_CALCULATE_F6_FOR_DHKEY_CHECK,
378     SM_SC_W4_CALCULATE_F6_FOR_DHKEY_CHECK,
379     SM_SC_W2_CALCULATE_F6_TO_VERIFY_DHKEY_CHECK,
380     SM_SC_W4_CALCULATE_F6_TO_VERIFY_DHKEY_CHECK,
381     SM_SC_W4_USER_RESPONSE,
382     SM_SC_SEND_DHKEY_CHECK_COMMAND,
383     SM_SC_W4_DHKEY_CHECK_COMMAND,
384     SM_SC_W4_LTK_REQUEST_SC,
385     SM_SC_W2_CALCULATE_ILK_USING_H6,
386 	SM_SC_W2_CALCULATE_ILK_USING_H7,
387     SM_SC_W4_CALCULATE_ILK,
388     SM_SC_W2_CALCULATE_BR_EDR_LINK_KEY,
389     SM_SC_W4_CALCULATE_BR_EDR_LINK_KEY,
390 } security_manager_state_t;
391 
392 typedef enum {
393     IRK_LOOKUP_IDLE,
394     IRK_LOOKUP_W4_READY,
395     IRK_LOOKUP_STARTED,
396     IRK_LOOKUP_SUCCEEDED,
397     IRK_LOOKUP_FAILED
398 } irk_lookup_state_t;
399 
400 typedef uint8_t sm_pairing_packet_t[7];
401 
402 // connection info available as long as connection exists
403 typedef struct sm_connection {
404     hci_con_handle_t         sm_handle;
405     uint8_t                  sm_role;   // 0 - IamMaster, 1 = IamSlave
406     uint8_t                  sm_security_request_received;
407     uint8_t                  sm_pairing_requested;
408     uint8_t                  sm_peer_addr_type;
409     bd_addr_t                sm_peer_address;
410     security_manager_state_t sm_engine_state;
411     irk_lookup_state_t       sm_irk_lookup_state;
412     uint8_t                  sm_connection_encrypted;
413     uint8_t                  sm_connection_authenticated;   // [0..1]
414     uint8_t                  sm_connection_sc;
415     uint8_t                  sm_actual_encryption_key_size;
416     sm_pairing_packet_t      sm_m_preq;  // only used during c1
417     authorization_state_t    sm_connection_authorization_state;
418     uint16_t                 sm_local_ediv;
419     uint8_t                  sm_local_rand[8];
420     int                      sm_le_db_index;
421     bool                     sm_pairing_active;
422     bool                     sm_reencryption_active;
423 } sm_connection_t;
424 
425 //
426 // ATT Server
427 //
428 
429 // max ATT request matches L2CAP PDU -- allow to use smaller buffer
430 #ifndef ATT_REQUEST_BUFFER_SIZE
431 #define ATT_REQUEST_BUFFER_SIZE HCI_ACL_PAYLOAD_SIZE
432 #endif
433 
434 typedef enum {
435     ATT_SERVER_IDLE,
436     ATT_SERVER_REQUEST_RECEIVED,
437     ATT_SERVER_W4_SIGNED_WRITE_VALIDATION,
438     ATT_SERVER_REQUEST_RECEIVED_AND_VALIDATED,
439     ATT_SERVER_RESPONSE_PENDING,
440 } att_server_state_t;
441 
442 typedef struct {
443     att_server_state_t      state;
444 
445     uint8_t                 peer_addr_type;
446     bd_addr_t               peer_address;
447 
448     int                     ir_le_device_db_index;
449     uint8_t                 ir_lookup_active;
450     uint8_t                 pairing_active;
451 
452     int                     value_indication_handle;
453     btstack_timer_source_t  value_indication_timer;
454 
455     btstack_linked_list_t   notification_requests;
456     btstack_linked_list_t   indication_requests;
457 
458 #ifdef ENABLE_GATT_OVER_CLASSIC
459     uint16_t                l2cap_cid;
460 #endif
461 
462     uint16_t                request_size;
463     uint8_t                 request_buffer[ATT_REQUEST_BUFFER_SIZE];
464 
465 } att_server_t;
466 
467 #endif
468 
469 #ifdef ENABLE_L2CAP_ENHANCED_RETRANSMISSION_MODE
470 typedef enum {
471     L2CAP_INFORMATION_STATE_IDLE = 0,
472     L2CAP_INFORMATION_STATE_W2_SEND_EXTENDED_FEATURE_REQUEST,
473     L2CAP_INFORMATION_STATE_W4_EXTENDED_FEATURE_RESPONSE,
474     L2CAP_INFORMATION_STATE_DONE
475 } l2cap_information_state_t;
476 
477 typedef struct {
478     l2cap_information_state_t information_state;
479     uint16_t                  extended_feature_mask;
480 } l2cap_state_t;
481 #endif
482 
483 //
484 typedef struct {
485     // linked list - assert: first field
486     btstack_linked_item_t    item;
487 
488     // remote side
489     bd_addr_t address;
490 
491     // module handle
492     hci_con_handle_t con_handle;
493 
494     // le public, le random, classic
495     bd_addr_type_t address_type;
496 
497     // role: 0 - master, 1 - slave
498     uint8_t role;
499 
500     // connection state
501     CONNECTION_STATE state;
502 
503     // bonding
504     uint16_t bonding_flags;
505     uint8_t  bonding_status;
506 
507     // encryption key size (in octets)
508     uint8_t encryption_key_size;
509 
510     // requested security level
511     gap_security_level_t requested_security_level;
512 
513     //
514     link_key_type_t link_key_type;
515 
516     // remote supported features
517     /* bit 0 - eSCO */
518     /* bit 1 - extended features */
519     uint8_t remote_supported_features[1];
520 
521 #ifdef ENABLE_CLASSIC
522     // connection mode, default ACL_CONNECTION_MODE_ACTIVE
523     uint8_t connection_mode;
524 
525     // enter/exit sniff mode requests
526     uint16_t sniff_min_interval;    // 0: idle, 0xffff exit sniff, else enter sniff
527     uint16_t sniff_max_interval;
528     uint16_t sniff_attempt;
529     uint16_t sniff_timeout;
530 
531     // track SCO rx event
532     uint32_t sco_rx_ms;
533     uint8_t  sco_rx_count;
534     uint8_t  sco_rx_valid;
535 
536     // generate sco can send now based on received packets, using timeout below
537     uint8_t  sco_tx_ready;
538 
539     // request role switch
540     hci_role_t request_role;
541 
542     btstack_timer_source_t timeout_sco;
543 #endif /* ENABLE_CLASSIC */
544 
545     // authentication and other errands
546     uint32_t authentication_flags;
547 
548     btstack_timer_source_t timeout;
549 
550     // timeout in system ticks (HAVE_EMBEDDED_TICK) or milliseconds (HAVE_EMBEDDED_TIME_MS)
551     uint32_t timestamp;
552 
553     // ACL packet recombination - PRE_BUFFER + ACL Header + ACL payload
554     uint8_t  acl_recombination_buffer[HCI_INCOMING_PRE_BUFFER_SIZE + 4 + HCI_ACL_BUFFER_SIZE];
555     uint16_t acl_recombination_pos;
556     uint16_t acl_recombination_length;
557 
558 
559     // number packets sent to controller
560     uint8_t num_packets_sent;
561 
562 #ifdef ENABLE_HCI_CONTROLLER_TO_HOST_FLOW_CONTROL
563     uint8_t num_packets_completed;
564 #endif
565 
566     // LE Connection parameter update
567     le_con_parameter_update_state_t le_con_parameter_update_state;
568     uint8_t  le_con_param_update_identifier;
569     uint16_t le_conn_interval_min;
570     uint16_t le_conn_interval_max;
571     uint16_t le_conn_latency;
572     uint16_t le_supervision_timeout;
573 
574 #ifdef ENABLE_BLE
575     uint16_t le_connection_interval;
576 
577     // LE PHY Update via set phy command
578     uint8_t le_phy_update_all_phys;      // 0xff for idle
579     uint8_t le_phy_update_tx_phys;
580     uint8_t le_phy_update_rx_phys;
581     int8_t  le_phy_update_phy_options;
582 
583     // LE Security Manager
584     sm_connection_t sm_connection;
585 
586 #ifdef ENABLE_LE_LIMIT_ACL_FRAGMENT_BY_MAX_OCTETS
587     uint16_t le_max_tx_octets;
588 #endif
589 
590     // ATT Connection
591     att_connection_t att_connection;
592 
593     // ATT Server
594     att_server_t    att_server;
595 
596 #endif
597 
598 #ifdef ENABLE_L2CAP_ENHANCED_RETRANSMISSION_MODE
599     l2cap_state_t l2cap_state;
600 #endif
601 
602 #ifdef ENABLE_CLASSIC_PAIRING_OOB
603     const uint8_t * classic_oob_c_192;
604     const uint8_t * classic_oob_r_192;
605     const uint8_t * classic_oob_c_256;
606     const uint8_t * classic_oob_r_256;
607 #endif
608 
609 } hci_connection_t;
610 
611 
612 /**
613  * HCI Inititizlization State Machine
614  */
615 typedef enum hci_init_state{
616     HCI_INIT_SEND_RESET = 0,
617     HCI_INIT_W4_SEND_RESET,
618     HCI_INIT_SEND_READ_LOCAL_VERSION_INFORMATION,
619     HCI_INIT_W4_SEND_READ_LOCAL_VERSION_INFORMATION,
620     HCI_INIT_SEND_READ_LOCAL_NAME,
621     HCI_INIT_W4_SEND_READ_LOCAL_NAME,
622 
623     HCI_INIT_SEND_BAUD_CHANGE,
624     HCI_INIT_W4_SEND_BAUD_CHANGE,
625     HCI_INIT_CUSTOM_INIT,
626     HCI_INIT_W4_CUSTOM_INIT,
627     HCI_INIT_SEND_RESET_CSR_WARM_BOOT,
628     HCI_INIT_W4_CUSTOM_INIT_CSR_WARM_BOOT,
629     HCI_INIT_W4_CUSTOM_INIT_CSR_WARM_BOOT_LINK_RESET,
630     HCI_INIT_W4_CUSTOM_INIT_BCM_DELAY,
631 
632     HCI_INIT_READ_LOCAL_SUPPORTED_COMMANDS,
633     HCI_INIT_W4_READ_LOCAL_SUPPORTED_COMMANDS,
634 
635     HCI_INIT_SEND_BAUD_CHANGE_BCM,
636     HCI_INIT_W4_SEND_BAUD_CHANGE_BCM,
637 
638     HCI_INIT_SET_BD_ADDR,
639     HCI_INIT_W4_SET_BD_ADDR,
640 
641     HCI_INIT_SEND_RESET_ST_WARM_BOOT,
642     HCI_INIT_W4_SEND_RESET_ST_WARM_BOOT,
643 
644     HCI_INIT_READ_BD_ADDR,
645     HCI_INIT_W4_READ_BD_ADDR,
646 
647     HCI_INIT_READ_BUFFER_SIZE,
648     HCI_INIT_W4_READ_BUFFER_SIZE,
649     HCI_INIT_READ_LOCAL_SUPPORTED_FEATURES,
650     HCI_INIT_W4_READ_LOCAL_SUPPORTED_FEATURES,
651 
652 #ifdef ENABLE_HCI_CONTROLLER_TO_HOST_FLOW_CONTROL
653     HCI_INIT_HOST_BUFFER_SIZE,
654     HCI_INIT_W4_HOST_BUFFER_SIZE,
655     HCI_INIT_SET_CONTROLLER_TO_HOST_FLOW_CONTROL,
656     HCI_INIT_W4_SET_CONTROLLER_TO_HOST_FLOW_CONTROL,
657 #endif
658 
659     HCI_INIT_SET_EVENT_MASK,
660     HCI_INIT_W4_SET_EVENT_MASK,
661 
662     HCI_INIT_WRITE_SIMPLE_PAIRING_MODE,
663     HCI_INIT_W4_WRITE_SIMPLE_PAIRING_MODE,
664     HCI_INIT_WRITE_PAGE_TIMEOUT,
665     HCI_INIT_W4_WRITE_PAGE_TIMEOUT,
666     HCI_INIT_WRITE_DEFAULT_LINK_POLICY_SETTING,
667     HCI_INIT_W4_WRITE_DEFAULT_LINK_POLICY_SETTING,
668     HCI_INIT_WRITE_CLASS_OF_DEVICE,
669     HCI_INIT_W4_WRITE_CLASS_OF_DEVICE,
670     HCI_INIT_WRITE_LOCAL_NAME,
671     HCI_INIT_W4_WRITE_LOCAL_NAME,
672     HCI_INIT_WRITE_EIR_DATA,
673     HCI_INIT_W4_WRITE_EIR_DATA,
674     HCI_INIT_WRITE_INQUIRY_MODE,
675     HCI_INIT_W4_WRITE_INQUIRY_MODE,
676     HCI_INIT_WRITE_SECURE_CONNECTIONS_HOST_ENABLE,
677     HCI_INIT_W4_WRITE_SECURE_CONNECTIONS_HOST_ENABLE,
678     HCI_INIT_WRITE_SCAN_ENABLE,
679     HCI_INIT_W4_WRITE_SCAN_ENABLE,
680 
681     // SCO over HCI
682     HCI_INIT_WRITE_SYNCHRONOUS_FLOW_CONTROL_ENABLE,
683     HCI_INIT_W4_WRITE_SYNCHRONOUS_FLOW_CONTROL_ENABLE,
684     HCI_INIT_WRITE_DEFAULT_ERRONEOUS_DATA_REPORTING,
685     HCI_INIT_W4_WRITE_DEFAULT_ERRONEOUS_DATA_REPORTING,
686 
687     // Broadcom SCO Routing
688     HCI_INIT_BCM_WRITE_SCO_PCM_INT,
689     HCI_INIT_W4_BCM_WRITE_SCO_PCM_INT,
690 
691 #ifdef ENABLE_BLE
692     HCI_INIT_LE_READ_BUFFER_SIZE,
693     HCI_INIT_W4_LE_READ_BUFFER_SIZE,
694     HCI_INIT_WRITE_LE_HOST_SUPPORTED,
695     HCI_INIT_W4_WRITE_LE_HOST_SUPPORTED,
696     HCI_INIT_LE_SET_EVENT_MASK,
697     HCI_INIT_W4_LE_SET_EVENT_MASK,
698 #endif
699 
700 #ifdef ENABLE_LE_DATA_LENGTH_EXTENSION
701     HCI_INIT_LE_READ_MAX_DATA_LENGTH,
702     HCI_INIT_W4_LE_READ_MAX_DATA_LENGTH,
703     HCI_INIT_LE_WRITE_SUGGESTED_DATA_LENGTH,
704     HCI_INIT_W4_LE_WRITE_SUGGESTED_DATA_LENGTH,
705 #endif
706 
707 #ifdef ENABLE_LE_CENTRAL
708     HCI_INIT_READ_WHITE_LIST_SIZE,
709     HCI_INIT_W4_READ_WHITE_LIST_SIZE,
710 
711     HCI_INIT_LE_SET_SCAN_PARAMETERS,
712     HCI_INIT_W4_LE_SET_SCAN_PARAMETERS,
713 #endif
714 
715     HCI_INIT_DONE,
716 
717     HCI_FALLING_ASLEEP_DISCONNECT,
718     HCI_FALLING_ASLEEP_W4_WRITE_SCAN_ENABLE,
719     HCI_FALLING_ASLEEP_COMPLETE,
720 
721     HCI_INIT_AFTER_SLEEP,
722 
723     HCI_HALTING_DISCONNECT_ALL_NO_TIMER,
724     HCI_HALTING_DISCONNECT_ALL_TIMER,
725     HCI_HALTING_W4_TIMER,
726     HCI_HALTING_CLOSE,
727 
728 } hci_substate_t;
729 
730 enum {
731     LE_ADVERTISEMENT_TASKS_SET_ADV_DATA  = 1 << 0,
732     LE_ADVERTISEMENT_TASKS_SET_SCAN_DATA = 1 << 1,
733     LE_ADVERTISEMENT_TASKS_SET_PARAMS    = 1 << 2,
734 };
735 
736 enum {
737     LE_WHITELIST_ON_CONTROLLER          = 1 << 0,
738     LE_WHITELIST_ADD_TO_CONTROLLER      = 1 << 1,
739     LE_WHITELIST_REMOVE_FROM_CONTROLLER = 1 << 2,
740 };
741 
742 typedef struct {
743     btstack_linked_item_t  item;
744     bd_addr_t      address;
745     bd_addr_type_t address_type;
746     uint8_t        state;
747 } whitelist_entry_t;
748 
749 #define MAX_NUM_RESOLVING_LIST_ENTRIES 64
750 typedef enum {
751     LE_RESOLVING_LIST_SEND_ENABLE_ADDRESS_RESOLUTION,
752     LE_RESOLVING_LIST_READ_SIZE,
753     LE_RESOLVING_LIST_SEND_CLEAR,
754 	LE_RESOLVING_LIST_REMOVE_ENTRIES,
755     LE_RESOLVING_LIST_ADD_ENTRIES,
756     LE_RESOLVING_LIST_DONE
757 } le_resolving_list_state_t;
758 
759 /**
760  * main data structure
761  */
762 typedef struct {
763     // transport component with configuration
764     const hci_transport_t * hci_transport;
765     const void            * config;
766 
767     // chipset driver
768     const btstack_chipset_t * chipset;
769 
770     // hardware power controller
771     const btstack_control_t * control;
772 
773     /* link key db */
774     const btstack_link_key_db_t * link_key_db;
775 
776     // list of existing baseband connections
777     btstack_linked_list_t     connections;
778 
779     /* callback to L2CAP layer */
780     btstack_packet_handler_t acl_packet_handler;
781 
782     /* callback for SCO data */
783     btstack_packet_handler_t sco_packet_handler;
784 
785     /* callbacks for events */
786     btstack_linked_list_t event_handlers;
787 
788 #ifdef ENABLE_CLASSIC
789     /* callback for reject classic connection */
790     int (*gap_classic_accept_callback)(bd_addr_t addr, hci_link_type_t link_type);
791 #endif
792 
793     // hardware error callback
794     void (*hardware_error_callback)(uint8_t error);
795 
796     // basic configuration
797     const char *       local_name;
798     const uint8_t *    eir_data;
799     uint32_t           class_of_device;
800     bd_addr_t          local_bd_addr;
801     uint8_t            default_link_policy_settings;
802     uint8_t            allow_role_switch;
803     uint8_t            ssp_enable;
804     uint8_t            ssp_io_capability;
805     uint8_t            ssp_authentication_requirement;
806     uint8_t            ssp_auto_accept;
807     bool               secure_connections_enable;
808     bool               secure_connections_active;
809     inquiry_mode_t     inquiry_mode;
810 #ifdef ENABLE_CLASSIC
811     // Errata-11838 mandates 7 bytes for GAP Security Level 1-3, we use 16 as default
812     uint8_t            gap_required_encyrption_key_size;
813     uint16_t           link_supervision_timeout;
814     gap_security_level_t gap_security_level;
815 #endif
816 
817     // single buffer for HCI packet assembly + additional prebuffer for H4 drivers
818     uint8_t   * hci_packet_buffer;
819     uint8_t   hci_packet_buffer_data[HCI_OUTGOING_PRE_BUFFER_SIZE + HCI_OUTGOING_PACKET_BUFFER_SIZE];
820     uint8_t   hci_packet_buffer_reserved;
821     uint16_t  acl_fragmentation_pos;
822     uint16_t  acl_fragmentation_total_size;
823     uint8_t   acl_fragmentation_tx_active;
824 
825     /* host to controller flow control */
826     uint8_t  num_cmd_packets;
827     uint8_t  acl_packets_total_num;
828     uint16_t acl_data_packet_length;
829     uint8_t  sco_packets_total_num;
830     uint8_t  sco_data_packet_length;
831     uint8_t  synchronous_flow_control_enabled;
832     uint8_t  le_acl_packets_total_num;
833     uint16_t le_data_packets_length;
834     uint8_t  sco_waiting_for_can_send_now;
835     uint8_t  sco_can_send_now;
836 
837     /* local supported features */
838     uint8_t local_supported_features[8];
839 
840     /* local supported commands summary - complete info is 64 bytes */
841     /*  0 - Read Buffer Size                        (Octet 14/bit 7) */
842     /*  1 - Write Le Host Supported                 (Octet 24/bit 6) */
843     /*  2 - Write Synchronous Flow Control Enable   (Octet 10/bit 4) */
844     /*  3 - Write Default Erroneous Data Reporting  (Octet 18/bit 3) */
845     /*  4 - LE Write Suggested Default Data Length  (Octet 34/bit 0) */
846     /*  5 - LE Read Maximum Data Length             (Octet 35/bit 3) */
847     /*  6 - LE Set Default PHY                      (Octet 35/bit 5) */
848     /*  7 - Read Encryption Key Size                (Octet 20/bit 4) */
849     /*  8 - Read Remote Extended Features           (Octet  2/bit 5) */
850     /*  9 - Write Secure Connections Host           (Octet 32/bit 3) */
851     /* 10 - LE Set Address Resolution Enable        (Octet 35/bit 1) */
852     /* 11 - Remote OOB Extended Data Request Reply  (Octet 32/bit 1) */
853     /* 12 - Read Local OOB Extended Data command    (Octet 32/bit 6) */
854     uint8_t local_supported_commands[2];
855 
856     /* bluetooth device information from hci read local version information */
857     // uint16_t hci_version;
858     // uint16_t hci_revision;
859     // uint16_t lmp_version;
860     uint16_t manufacturer;
861     // uint16_t lmp_subversion;
862 
863     // usable packet types given acl_data_packet_length and HCI_ACL_BUFFER_SIZE
864     uint16_t packet_types;
865 
866 
867     /* hci state machine */
868     HCI_STATE      state;
869     hci_substate_t substate;
870     btstack_timer_source_t timeout;
871     btstack_chipset_result_t chipset_result;
872 
873     uint16_t  last_cmd_opcode;
874 
875     uint8_t   cmds_ready;
876 
877     /* buffer for scan enable cmd - 0xff no change */
878     uint8_t   new_scan_enable_value;
879 
880     uint8_t   discoverable;
881     uint8_t   connectable;
882     uint8_t   bondable;
883 
884     uint8_t   inquiry_state;    // see hci.c for state defines
885 
886     bd_addr_t remote_name_addr;
887     uint16_t  remote_name_clock_offset;
888     uint8_t   remote_name_page_scan_repetition_mode;
889     uint8_t   remote_name_state;    // see hci.c for state defines
890 
891     bd_addr_t gap_pairing_addr;
892     uint8_t   gap_pairing_state;    // see hci.c for state defines
893     uint8_t   gap_pairing_pin_len;
894     union {
895         const uint8_t * gap_pairing_pin;
896         uint32_t     gap_pairing_passkey;
897     } gap_pairing_input;
898 
899     uint16_t  sco_voice_setting;
900     uint16_t  sco_voice_setting_active;
901 
902     uint8_t   loopback_mode;
903 
904     // buffer for single connection decline
905     uint8_t   decline_reason;
906     bd_addr_t decline_addr;
907 
908 #ifdef ENABLE_HCI_CONTROLLER_TO_HOST_FLOW_CONTROL
909     uint8_t   host_completed_packets;
910 #endif
911 
912 #ifdef ENABLE_BLE
913     uint8_t   le_own_addr_type;
914     bd_addr_t le_random_address;
915     uint8_t   le_random_address_set;
916 
917     // LE Whitelist Management
918     uint8_t               le_whitelist_capacity;
919     btstack_linked_list_t le_whitelist;
920 #endif
921 
922 #ifdef ENABLE_LE_CENTRAL
923     bool   le_scanning_enabled;
924     bool   le_scanning_active;
925 
926     le_connecting_state_t le_connecting_state;
927     le_connecting_state_t le_connecting_request;
928 
929     bool     le_scanning_param_update;
930     uint8_t  le_scan_type;
931     uint8_t  le_scan_filter_policy;
932     uint16_t le_scan_interval;
933     uint16_t le_scan_window;
934 
935     // Connection parameters
936     uint16_t le_connection_interval_min;
937     uint16_t le_connection_interval_max;
938     uint16_t le_connection_latency;
939     uint16_t le_supervision_timeout;
940     uint16_t le_minimum_ce_length;
941     uint16_t le_maximum_ce_length;
942     uint16_t le_connection_scan_interval;
943     uint16_t le_connection_scan_window;
944 #endif
945 
946     le_connection_parameter_range_t le_connection_parameter_range;
947 
948 #ifdef ENABLE_LE_PERIPHERAL
949     uint8_t  * le_advertisements_data;
950     uint8_t    le_advertisements_data_len;
951 
952     uint8_t  * le_scan_response_data;
953     uint8_t    le_scan_response_data_len;
954 
955     bool     le_advertisements_active;
956     bool     le_advertisements_enabled;
957     bool     le_advertisements_enabled_for_current_roles;
958     uint8_t  le_advertisements_todo;
959 
960     uint16_t le_advertisements_interval_min;
961     uint16_t le_advertisements_interval_max;
962     uint8_t  le_advertisements_type;
963     uint8_t  le_advertisements_direct_address_type;
964     uint8_t  le_advertisements_channel_map;
965     uint8_t  le_advertisements_filter_policy;
966     bd_addr_t le_advertisements_direct_address;
967 
968     uint8_t le_max_number_peripheral_connections;
969 #endif
970 
971 #ifdef ENABLE_LE_DATA_LENGTH_EXTENSION
972     // LE Data Length
973     uint16_t le_supported_max_tx_octets;
974     uint16_t le_supported_max_tx_time;
975 #endif
976 
977     // custom BD ADDR
978     bd_addr_t custom_bd_addr;
979     uint8_t   custom_bd_addr_set;
980 
981 #ifdef ENABLE_CLASSIC
982     uint8_t master_slave_policy;
983 #endif
984 
985     // address and address_type of active create connection command (ACL, SCO, LE)
986     bd_addr_t      outgoing_addr;
987     bd_addr_type_t outgoing_addr_type;
988 
989     // LE Resolving List
990 #ifdef ENABLE_LE_PRIVACY_ADDRESS_RESOLUTION
991     le_resolving_list_state_t le_resolving_list_state;
992     uint16_t                  le_resolving_list_size;
993     uint8_t                   le_resolving_list_add_entries[(MAX_NUM_RESOLVING_LIST_ENTRIES + 7) / 8];
994 	uint8_t                   le_resolving_list_remove_entries[(MAX_NUM_RESOLVING_LIST_ENTRIES + 7) / 8];
995 #endif
996 
997 #ifdef ENABLE_CLASSIC_PAIRING_OOB
998 	bool                      classic_read_local_oob_data;
999 #endif
1000 } hci_stack_t;
1001 
1002 
1003 /* API_START */
1004 
1005 
1006 // HCI init and configuration
1007 
1008 
1009 /**
1010  * @brief Set up HCI. Needs to be called before any other function.
1011  */
1012 void hci_init(const hci_transport_t *transport, const void *config);
1013 
1014 /**
1015  * @brief Configure Bluetooth chipset driver. Has to be called before power on, or right after receiving the local version information.
1016  */
1017 void hci_set_chipset(const btstack_chipset_t *chipset_driver);
1018 
1019 /**
1020  * @brief Configure Bluetooth hardware control. Has to be called before power on.
1021  */
1022 void hci_set_control(const btstack_control_t *hardware_control);
1023 
1024 /**
1025  * @brief Configure Bluetooth hardware control. Has to be called before power on.
1026  */
1027 void hci_set_link_key_db(btstack_link_key_db_t const * link_key_db);
1028 
1029 /**
1030  * @brief Set callback for Bluetooth Hardware Error
1031  */
1032 void hci_set_hardware_error_callback(void (*fn)(uint8_t error));
1033 
1034 /**
1035  * @brief Set Public BD ADDR - passed on to Bluetooth chipset during init if supported in bt_control_h
1036  */
1037 void hci_set_bd_addr(bd_addr_t addr);
1038 
1039 /**
1040  * @brief Configure Voice Setting for use with SCO data in HSP/HFP
1041  */
1042 void hci_set_sco_voice_setting(uint16_t voice_setting);
1043 
1044 /**
1045  * @brief Get SCO Voice Setting
1046  * @return current voice setting
1047  */
1048 uint16_t hci_get_sco_voice_setting(void);
1049 
1050 /**
1051  * @brief Set inquiry mode: standard, with RSSI, with RSSI + Extended Inquiry Results. Has to be called before power on.
1052  * @param inquriy_mode see bluetooth_defines.h
1053  */
1054 void hci_set_inquiry_mode(inquiry_mode_t mode);
1055 
1056 /**
1057  * @brief Requests the change of BTstack power mode.
1058  */
1059 int  hci_power_control(HCI_POWER_MODE mode);
1060 
1061 /**
1062  * @brief Shutdown HCI
1063  */
1064 void hci_close(void);
1065 
1066 
1067 // Callback registration
1068 
1069 
1070 /**
1071  * @brief Add event packet handler.
1072  */
1073 void hci_add_event_handler(btstack_packet_callback_registration_t * callback_handler);
1074 
1075 /**
1076  * @brief Registers a packet handler for ACL data. Used by L2CAP
1077  */
1078 void hci_register_acl_packet_handler(btstack_packet_handler_t handler);
1079 
1080 /**
1081  * @brief Registers a packet handler for SCO data. Used for HSP and HFP profiles.
1082  */
1083 void hci_register_sco_packet_handler(btstack_packet_handler_t handler);
1084 
1085 
1086 // Sending HCI Commands
1087 
1088 /**
1089  * @brief Check if CMD packet can be sent to controller
1090  */
1091 int hci_can_send_command_packet_now(void);
1092 
1093 /**
1094  * @brief Creates and sends HCI command packets based on a template and a list of parameters. Will return error if outgoing data buffer is occupied.
1095  */
1096 int hci_send_cmd(const hci_cmd_t *cmd, ...);
1097 
1098 
1099 // Sending SCO Packets
1100 
1101 /** @brief Get SCO packet length for current SCO Voice setting
1102  *  @note  Using SCO packets of the exact length is required for USB transfer
1103  *  @return Length of SCO packets in bytes (not audio frames) incl. 3 byte header
1104  */
1105 int hci_get_sco_packet_length(void);
1106 
1107 /**
1108  * @brief Request emission of HCI_EVENT_SCO_CAN_SEND_NOW as soon as possible
1109  * @note HCI_EVENT_SCO_CAN_SEND_NOW might be emitted during call to this function
1110  *       so packet handler should be ready to handle it
1111  */
1112 void hci_request_sco_can_send_now_event(void);
1113 
1114 /**
1115  * @brief Check HCI packet buffer and if SCO packet can be sent to controller
1116  */
1117 int hci_can_send_sco_packet_now(void);
1118 
1119 /**
1120  * @brief Check if SCO packet can be sent to controller
1121  */
1122 int hci_can_send_prepared_sco_packet_now(void);
1123 
1124 /**
1125  * @brief Send SCO packet prepared in HCI packet buffer
1126  */
1127 int hci_send_sco_packet_buffer(int size);
1128 
1129 
1130 // Outgoing packet buffer, also used for SCO packets
1131 // see hci_can_send_prepared_sco_packet_now amn hci_send_sco_packet_buffer
1132 
1133 /**
1134  * Reserves outgoing packet buffer.
1135  * @return 1 on success
1136  */
1137 int hci_reserve_packet_buffer(void);
1138 
1139 /**
1140  * Get pointer for outgoing packet buffer
1141  */
1142 uint8_t* hci_get_outgoing_packet_buffer(void);
1143 
1144 /**
1145  * Release outgoing packet buffer\
1146  * @note only called instead of hci_send_preparared
1147  */
1148 void hci_release_packet_buffer(void);
1149 
1150 /**
1151 * @brief Sets the master/slave policy
1152 * @param policy (0: attempt to become master, 1: let connecting device decide)
1153 */
1154 void hci_set_master_slave_policy(uint8_t policy);
1155 
1156 /* API_END */
1157 
1158 
1159 /**
1160  * va_list version of hci_send_cmd, call hci_send_cmd_packet
1161  */
1162 int hci_send_cmd_va_arg(const hci_cmd_t *cmd, va_list argtr);
1163 
1164 /**
1165  * Get connection iterator. Only used by l2cap.c and sm.c
1166  */
1167 void hci_connections_get_iterator(btstack_linked_list_iterator_t *it);
1168 
1169 /**
1170  * Get internal hci_connection_t for given handle. Used by L2CAP, SM, daemon
1171  */
1172 hci_connection_t * hci_connection_for_handle(hci_con_handle_t con_handle);
1173 
1174 /**
1175  * Get internal hci_connection_t for given Bluetooth addres. Called by L2CAP
1176  */
1177 hci_connection_t * hci_connection_for_bd_addr_and_type(const bd_addr_t addr, bd_addr_type_t addr_type);
1178 
1179 /**
1180  * Check if outgoing packet buffer is reserved. Used for internal checks in l2cap.c
1181  */
1182 int hci_is_packet_buffer_reserved(void);
1183 
1184 /**
1185  * Check hci packet buffer is free and a classic acl packet can be sent to controller
1186  */
1187 int hci_can_send_acl_classic_packet_now(void);
1188 
1189 /**
1190  * Check hci packet buffer is free and an LE acl packet can be sent to controller
1191  */
1192 int hci_can_send_acl_le_packet_now(void);
1193 
1194 /**
1195  * Check hci packet buffer is free and an acl packet for the given handle can be sent to controller
1196  */
1197 int hci_can_send_acl_packet_now(hci_con_handle_t con_handle);
1198 
1199 /**
1200  * Check if acl packet for the given handle can be sent to controller
1201  */
1202 int hci_can_send_prepared_acl_packet_now(hci_con_handle_t con_handle);
1203 
1204 /**
1205  * Send acl packet prepared in hci packet buffer
1206  */
1207 int hci_send_acl_packet_buffer(int size);
1208 
1209 /**
1210  * Check if authentication is active. It delays automatic disconnect while no L2CAP connection
1211  * Called by l2cap.
1212  */
1213 int hci_authentication_active_for_handle(hci_con_handle_t handle);
1214 
1215 /**
1216  * Get maximal ACL Classic data packet length based on used buffer size. Called by L2CAP
1217  */
1218 uint16_t hci_max_acl_data_packet_length(void);
1219 
1220 /**
1221  * Get supported packet types. Called by L2CAP
1222  */
1223 uint16_t hci_usable_acl_packet_types(void);
1224 
1225 /**
1226  * Check if ACL packets marked as non flushable can be sent. Called by L2CAP
1227  */
1228 int hci_non_flushable_packet_boundary_flag_supported(void);
1229 
1230 /**
1231  * Check if extended SCO Link is supported
1232  */
1233 int hci_extended_sco_link_supported(void);
1234 
1235 /**
1236  * Check if SSP is supported on both sides. Called by L2CAP
1237  */
1238 int gap_ssp_supported_on_both_sides(hci_con_handle_t handle);
1239 
1240 /**
1241  * Disconn because of security block. Called by L2CAP
1242  */
1243 void hci_disconnect_security_block(hci_con_handle_t con_handle);
1244 
1245 /**
1246  * Query if remote side supports eSCO
1247  */
1248 int hci_remote_esco_supported(hci_con_handle_t con_handle);
1249 
1250 /**
1251  * Emit current HCI state. Called by daemon
1252  */
1253 void hci_emit_state(void);
1254 
1255 /**
1256  * Send complete CMD packet. Called by daemon and hci_send_cmd_va_arg
1257  * @returns 0 if command was successfully sent to HCI Transport layer
1258  */
1259 int hci_send_cmd_packet(uint8_t *packet, int size);
1260 
1261 /**
1262  * Disconnect all HCI connections. Called by daemon
1263  */
1264 void hci_disconnect_all(void);
1265 
1266 /**
1267  * Get number of free acl slots for packets of given handle. Called by daemon
1268  */
1269 int hci_number_free_acl_slots_for_handle(hci_con_handle_t con_handle);
1270 
1271 /**
1272  * @brief Set Advertisement Parameters
1273  * @param adv_int_min
1274  * @param adv_int_max
1275  * @param adv_type
1276  * @param direct_address_type
1277  * @param direct_address
1278  * @param channel_map
1279  * @param filter_policy
1280  *
1281  * @note internal use. use gap_advertisements_set_params from gap.h instead.
1282  */
1283 void hci_le_advertisements_set_params(uint16_t adv_int_min, uint16_t adv_int_max, uint8_t adv_type,
1284     uint8_t direct_address_typ, bd_addr_t direct_address, uint8_t channel_map, uint8_t filter_policy);
1285 
1286 /**
1287  *
1288  * @note internal use. use gap_random_address_set_mode from gap.h instead.
1289  */
1290 void hci_le_set_own_address_type(uint8_t own_address_type);
1291 
1292 /**
1293  * @note internal use by sm
1294  */
1295 void hci_load_le_device_db_entry_into_resolving_list(uint16_t le_device_db_index);
1296 
1297 /**
1298  * @note internal use by sm
1299  */
1300 void hci_remove_le_device_db_entry_from_resolving_list(uint16_t le_device_db_index);
1301 
1302 /**
1303  * @brief Get Manufactured
1304  * @return manufacturer id
1305  */
1306 uint16_t hci_get_manufacturer(void);
1307 
1308 /**
1309  * Defer halt. Used by btstack_crypto to allow current HCI operation to complete
1310  */
1311 void hci_halting_defer(void);
1312 
1313 // Only for PTS testing
1314 
1315 /**
1316  * Disable automatic L2CAP disconnect if no L2CAP connection is established
1317  */
1318 void hci_disable_l2cap_timeout_check(void);
1319 
1320 /**
1321  *  Get Classic Allow Role Switch param
1322  */
1323 uint8_t hci_get_allow_role_switch(void);
1324 
1325 /**
1326  * Get state
1327  */
1328 HCI_STATE hci_get_state(void);
1329 
1330 /**
1331  * @brief De-Init HCI
1332  */
1333 void hci_deinit(void);
1334 
1335 // setup test connections, used for fuzzing
1336 void hci_setup_test_connections_fuzz(void);
1337 
1338 // free all connections, used for fuzzing
1339 void hci_free_connections_fuzz(void);
1340 
1341 // simulate stack bootup
1342 void hci_simulate_working_fuzz(void);
1343 
1344 
1345 #if defined __cplusplus
1346 }
1347 #endif
1348 
1349 #endif // HCI_H
1350