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