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 BLUEKITCHEN 24 * GMBH 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 #define BTSTACK_FILE__ "hfp.c" 39 40 41 #include "btstack_config.h" 42 43 #include <stdint.h> 44 #include <stdio.h> 45 #include <string.h> 46 #include <inttypes.h> 47 48 #include "bluetooth_sdp.h" 49 #include "btstack_debug.h" 50 #include "btstack_event.h" 51 #include "btstack_memory.h" 52 #include "btstack_run_loop.h" 53 #include "classic/sdp_client_rfcomm.h" 54 #include "classic/sdp_server.h" 55 #include "classic/sdp_util.h" 56 #include "classic/sdp_client.h" 57 #include "hci.h" 58 #include "hci_cmd.h" 59 #include "hci_dump.h" 60 61 #if defined(ENABLE_CC256X_ASSISTED_HFP) && !defined(ENABLE_SCO_OVER_PCM) 62 #error "Assisted HFP is only possible over PCM/I2S. Please add define: ENABLE_SCO_OVER_PCM" 63 #endif 64 65 #if defined(ENABLE_BCM_PCM_WBS) && !defined(ENABLE_SCO_OVER_PCM) 66 #error "WBS for PCM is only possible over PCM/I2S. Please add define: ENABLE_SCO_OVER_PCM" 67 #endif 68 69 #define HFP_HF_FEATURES_SIZE 10 70 #define HFP_AG_FEATURES_SIZE 12 71 72 typedef struct { 73 hfp_role_t local_role; 74 bd_addr_t remote_address; 75 } hfp_sdp_query_context_t; 76 77 // globals 78 79 static btstack_linked_list_t hfp_connections ; 80 81 static btstack_packet_handler_t hfp_hf_callback; 82 static btstack_packet_handler_t hfp_ag_callback; 83 84 static btstack_packet_handler_t hfp_hf_rfcomm_packet_handler; 85 static btstack_packet_handler_t hfp_ag_rfcomm_packet_handler; 86 87 static uint8_t hfp_hf_indicators_nr; 88 static const uint8_t * hfp_hf_indicators; 89 90 static uint16_t hfp_allowed_sco_packet_types; 91 static hfp_connection_t * hfp_sco_establishment_active; 92 93 static hfp_sdp_query_context_t hfp_sdp_query_context; 94 static btstack_context_callback_registration_t hfp_sdp_query_request; 95 96 97 98 99 100 // custom commands 101 static btstack_linked_list_t hfp_custom_commands_ag; 102 static btstack_linked_list_t hfp_custom_commands_hf; 103 104 // prototypes 105 static hfp_link_settings_t hfp_next_link_setting_for_connection(hfp_link_settings_t current_setting, hfp_connection_t * hfp_connection, uint8_t eSCO_S4_supported); 106 static void parse_sequence(hfp_connection_t * context); 107 108 109 #define CODEC_MASK_CVSD (1 << HFP_CODEC_CVSD) 110 #define CODEC_MASK_OTHER ((1 << HFP_CODEC_MSBC) | (1 << HFP_CODEC_LC3_SWB)) 111 112 static const struct { 113 const uint16_t max_latency; 114 const uint8_t retransmission_effort; 115 const uint16_t packet_types; 116 const uint8_t codec_mask; 117 } hfp_link_settings [] = { 118 {0x0004, 0xff, SCO_PACKET_TYPES_HV1, CODEC_MASK_CVSD }, // HFP_LINK_SETTINGS_D0 119 {0x0005, 0xff, SCO_PACKET_TYPES_HV3, CODEC_MASK_CVSD }, // HFP_LINK_SETTINGS_D1 120 {0x0007, 0x01, SCO_PACKET_TYPES_EV3, CODEC_MASK_CVSD }, // HFP_LINK_SETTINGS_S1 121 {0x0007, 0x01, SCO_PACKET_TYPES_2EV3, CODEC_MASK_CVSD }, // HFP_LINK_SETTINGS_S2 122 {0x000a, 0x01, SCO_PACKET_TYPES_2EV3, CODEC_MASK_CVSD }, // HFP_LINK_SETTINGS_S3 123 {0x000c, 0x02, SCO_PACKET_TYPES_2EV3, CODEC_MASK_CVSD }, // HFP_LINK_SETTINGS_S4 124 {0x0008, 0x02, SCO_PACKET_TYPES_EV3, CODEC_MASK_OTHER}, // HFP_LINK_SETTINGS_T1 125 {0x000d, 0x02, SCO_PACKET_TYPES_2EV3, CODEC_MASK_OTHER} // HFP_LINK_SETTINGS_T2 126 }; 127 128 #ifdef ENABLE_HFP_HF_SAFE_SETTINGS 129 // HFP v1.9, table 6.10 'mandatory safe settings' for eSCO + similar entries for SCO 130 static const struct hfp_mandatory_safe_setting { 131 const uint8_t codec_mask; 132 const bool secure_connection_in_use; 133 hfp_link_settings_t link_setting; 134 } hfp_mandatory_safe_settings[] = { 135 { CODEC_MASK_CVSD, false, HFP_LINK_SETTINGS_D1}, 136 { CODEC_MASK_CVSD, true, HFP_LINK_SETTINGS_D1}, 137 { CODEC_MASK_CVSD, false, HFP_LINK_SETTINGS_S1}, 138 { CODEC_MASK_CVSD, true, HFP_LINK_SETTINGS_S4}, 139 { CODEC_MASK_OTHER, false, HFP_LINK_SETTINGS_T1}, 140 { CODEC_MASK_OTHER, true, HFP_LINK_SETTINGS_T2}, 141 }; 142 #endif 143 144 static const char * hfp_hf_features[] = { 145 "EC and/or NR function", 146 "Three-way calling", 147 "CLI presentation capability", 148 "Voice recognition activation", 149 "Remote volume control", 150 151 "Enhanced call status", 152 "Enhanced call control", 153 154 "Codec negotiation", 155 156 "HF Indicators", 157 "eSCO S4 (and T2) Settings Supported", 158 "Reserved for future definition" 159 }; 160 161 static const char * hfp_ag_features[] = { 162 "Three-way calling", 163 "EC and/or NR function", 164 "Voice recognition function", 165 "In-band ring tone capability", 166 "Attach a number to a voice tag", 167 "Ability to reject a call", 168 "Enhanced call status", 169 "Enhanced call control", 170 "Extended Error Result Codes", 171 "Codec negotiation", 172 "HF Indicators", 173 "eSCO S4 (and T2) Settings Supported", 174 "Reserved for future definition" 175 }; 176 177 static const char * hfp_enhanced_call_dir[] = { 178 "outgoing", 179 "incoming" 180 }; 181 182 static const char * hfp_enhanced_call_status[] = { 183 "active", 184 "held", 185 "outgoing dialing", 186 "outgoing alerting", 187 "incoming", 188 "incoming waiting", 189 "call held by response and hold" 190 }; 191 192 static const char * hfp_enhanced_call_mode[] = { 193 "voice", 194 "data", 195 "fax" 196 }; 197 198 static const char * hfp_enhanced_call_mpty[] = { 199 "not a conference call", 200 "conference call" 201 }; 202 203 const char * hfp_enhanced_call_dir2str(uint16_t index){ 204 if (index <= HFP_ENHANCED_CALL_DIR_INCOMING) return hfp_enhanced_call_dir[index]; 205 return "not defined"; 206 } 207 208 const char * hfp_enhanced_call_status2str(uint16_t index){ 209 if (index <= HFP_ENHANCED_CALL_STATUS_CALL_HELD_BY_RESPONSE_AND_HOLD) return hfp_enhanced_call_status[index]; 210 return "not defined"; 211 } 212 213 const char * hfp_enhanced_call_mode2str(uint16_t index){ 214 if (index <= HFP_ENHANCED_CALL_MODE_FAX) return hfp_enhanced_call_mode[index]; 215 return "not defined"; 216 } 217 218 const char * hfp_enhanced_call_mpty2str(uint16_t index){ 219 if (index <= HFP_ENHANCED_CALL_MPTY_CONFERENCE_CALL) return hfp_enhanced_call_mpty[index]; 220 return "not defined"; 221 } 222 223 static uint16_t hfp_parse_indicator_index(hfp_connection_t * hfp_connection){ 224 uint16_t index = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 225 226 if (index > HFP_MAX_NUM_INDICATORS){ 227 log_info("ignoring invalid indicator index bigger then HFP_MAX_NUM_INDICATORS"); 228 return HFP_MAX_NUM_INDICATORS - 1; 229 } 230 231 // indicator index enumeration starts with 1, we substract 1 to store in array with starting index 0 232 if (index > 0){ 233 index -= 1; 234 } else { 235 log_info("ignoring invalid indicator index 0"); 236 return 0; 237 } 238 return index; 239 } 240 241 static void hfp_next_indicators_index(hfp_connection_t * hfp_connection){ 242 if (hfp_connection->parser_item_index < HFP_MAX_NUM_INDICATORS - 1){ 243 hfp_connection->parser_item_index++; 244 } else { 245 log_info("Ignoring additional indicator"); 246 } 247 } 248 249 static void hfp_next_codec_index(hfp_connection_t * hfp_connection){ 250 if (hfp_connection->parser_item_index < HFP_MAX_NUM_CODECS - 1){ 251 hfp_connection->parser_item_index++; 252 } else { 253 log_info("Ignoring additional codec index"); 254 } 255 } 256 257 static void hfp_next_remote_call_services_index(hfp_connection_t * hfp_connection){ 258 if (hfp_connection->remote_call_services_index < HFP_MAX_NUM_CALL_SERVICES - 1){ 259 hfp_connection->remote_call_services_index++; 260 } else { 261 log_info("Ignoring additional remote_call_services"); 262 } 263 } 264 265 const char * hfp_hf_feature(int index){ 266 if (index > HFP_HF_FEATURES_SIZE){ 267 return hfp_hf_features[HFP_HF_FEATURES_SIZE]; 268 } 269 return hfp_hf_features[index]; 270 } 271 272 const char * hfp_ag_feature(int index){ 273 if (index > HFP_AG_FEATURES_SIZE){ 274 return hfp_ag_features[HFP_AG_FEATURES_SIZE]; 275 } 276 return hfp_ag_features[index]; 277 } 278 279 int send_str_over_rfcomm(uint16_t cid, const char * command){ 280 if (!rfcomm_can_send_packet_now(cid)) return 1; 281 log_info("HFP_TX %s", command); 282 int err = rfcomm_send(cid, (uint8_t*) command, (uint16_t) strlen(command)); 283 if (err){ 284 log_error("rfcomm_send -> error 0x%02x \n", err); 285 } 286 #ifdef ENABLE_HFP_AT_MESSAGES 287 hfp_connection_t * hfp_connection = get_hfp_connection_context_for_rfcomm_cid(cid); 288 hfp_emit_string_event(hfp_connection, HFP_SUBEVENT_AT_MESSAGE_SENT, command); 289 #endif 290 return 1; 291 } 292 293 int hfp_supports_codec(uint8_t codec, int codecs_nr, uint8_t * codecs){ 294 295 // mSBC requires support for eSCO connections 296 if ((codec == HFP_CODEC_MSBC) && !hci_extended_sco_link_supported()) return 0; 297 298 int i; 299 for (i = 0; i < codecs_nr; i++){ 300 if (codecs[i] != codec) continue; 301 return 1; 302 } 303 return 0; 304 } 305 306 void hfp_hf_drop_mSBC_if_eSCO_not_supported(uint8_t * codecs, uint8_t * codecs_nr){ 307 if (hci_extended_sco_link_supported()) return; 308 uint8_t i; 309 int filtered_codec_count = 0; 310 for (i=0; i < *codecs_nr; i++){ 311 if (codecs[i] != HFP_CODEC_MSBC) { 312 codecs[filtered_codec_count++] = codecs[i]; 313 } 314 } 315 *codecs_nr = filtered_codec_count; 316 } 317 318 // UTILS 319 int get_bit(uint16_t bitmap, int position){ 320 return (bitmap >> position) & 1; 321 } 322 323 int store_bit(uint32_t bitmap, int position, uint8_t value){ 324 if (value){ 325 bitmap |= 1 << position; 326 } else { 327 bitmap &= ~ (1 << position); 328 } 329 return bitmap; 330 } 331 332 int join(char * buffer, int buffer_size, uint8_t * values, int values_nr){ 333 if (buffer_size < (values_nr * 3)) return 0; 334 int i; 335 int offset = 0; 336 for (i = 0; i < (values_nr-1); i++) { 337 offset += snprintf(buffer+offset, buffer_size-offset, "%d,", values[i]); // puts string into buffer 338 } 339 if (i<values_nr){ 340 offset += snprintf(buffer+offset, buffer_size-offset, "%d", values[i]); 341 } 342 return offset; 343 } 344 345 int join_bitmap(char * buffer, int buffer_size, uint32_t values, int values_nr){ 346 if (buffer_size < (values_nr * 3)) return 0; 347 348 int i; 349 int offset = 0; 350 for (i = 0; i < (values_nr-1); i++) { 351 offset += snprintf(buffer+offset, buffer_size-offset, "%d,", get_bit(values,i)); // puts string into buffer 352 } 353 354 if (i<values_nr){ 355 offset += snprintf(buffer+offset, buffer_size-offset, "%d", get_bit(values,i)); 356 } 357 return offset; 358 } 359 static void hfp_emit_event_for_role(hfp_role_t local_role, uint8_t * packet, uint16_t size){ 360 switch (local_role){ 361 case HFP_ROLE_HF: 362 (*hfp_hf_callback)(HCI_EVENT_PACKET, 0, packet, size); 363 break; 364 case HFP_ROLE_AG: 365 (*hfp_ag_callback)(HCI_EVENT_PACKET, 0, packet, size); 366 break; 367 default: 368 btstack_unreachable(); 369 break; 370 } 371 } 372 373 static void hfp_emit_event_for_context(hfp_connection_t * hfp_connection, uint8_t * packet, uint16_t size){ 374 if (!hfp_connection) return; 375 hfp_emit_event_for_role(hfp_connection->local_role, packet, size); 376 } 377 378 void hfp_emit_simple_event(hfp_connection_t * hfp_connection, uint8_t event_subtype){ 379 hci_con_handle_t acl_handle = (hfp_connection != NULL) ? hfp_connection->acl_handle : HCI_CON_HANDLE_INVALID; 380 uint8_t event[5]; 381 event[0] = HCI_EVENT_HFP_META; 382 event[1] = sizeof(event) - 2; 383 event[2] = event_subtype; 384 little_endian_store_16(event, 3, acl_handle); 385 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 386 } 387 388 void hfp_emit_event(hfp_connection_t * hfp_connection, uint8_t event_subtype, uint8_t value){ 389 hci_con_handle_t acl_handle = (hfp_connection != NULL) ? hfp_connection->acl_handle : HCI_CON_HANDLE_INVALID; 390 uint8_t event[6]; 391 event[0] = HCI_EVENT_HFP_META; 392 event[1] = sizeof(event) - 2; 393 event[2] = event_subtype; 394 little_endian_store_16(event, 3, acl_handle); 395 event[5] = value; // status 0 == OK 396 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 397 } 398 399 void hfp_emit_voice_recognition_enabled(hfp_connection_t * hfp_connection, uint8_t status){ 400 btstack_assert(hfp_connection != NULL); 401 402 uint8_t event[7]; 403 event[0] = HCI_EVENT_HFP_META; 404 event[1] = sizeof(event) - 2; 405 event[2] = HFP_SUBEVENT_VOICE_RECOGNITION_ACTIVATED; 406 407 little_endian_store_16(event, 3, hfp_connection->acl_handle); 408 event[5] = status; // 0:success 409 event[6] = hfp_connection->enhanced_voice_recognition_enabled ? 1 : 0; 410 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 411 } 412 413 void hfp_emit_voice_recognition_disabled(hfp_connection_t * hfp_connection, uint8_t status){ 414 btstack_assert(hfp_connection != NULL); 415 416 uint8_t event[6]; 417 event[0] = HCI_EVENT_HFP_META; 418 event[1] = sizeof(event) - 2; 419 event[2] = HFP_SUBEVENT_VOICE_RECOGNITION_DEACTIVATED; 420 421 little_endian_store_16(event, 3, hfp_connection->acl_handle); 422 event[5] = status; // 0:success 423 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 424 } 425 426 void hfp_emit_enhanced_voice_recognition_hf_ready_for_audio_event(hfp_connection_t * hfp_connection, uint8_t status){ 427 hci_con_handle_t acl_handle = (hfp_connection != NULL) ? hfp_connection->acl_handle : HCI_CON_HANDLE_INVALID; 428 429 uint8_t event[6]; 430 event[0] = HCI_EVENT_HFP_META; 431 event[1] = sizeof(event) - 2; 432 event[2] = HFP_SUBEVENT_ENHANCED_VOICE_RECOGNITION_HF_READY_FOR_AUDIO; 433 little_endian_store_16(event, 3, acl_handle); 434 event[5] = status; 435 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 436 } 437 438 void hfp_emit_enhanced_voice_recognition_state_event(hfp_connection_t * hfp_connection, uint8_t status){ 439 hci_con_handle_t acl_handle = (hfp_connection != NULL) ? hfp_connection->acl_handle : HCI_CON_HANDLE_INVALID; 440 441 uint8_t event[6]; 442 event[0] = HCI_EVENT_HFP_META; 443 event[1] = sizeof(event) - 2; 444 switch (hfp_connection->ag_vra_state){ 445 case HFP_VOICE_RECOGNITION_STATE_AG_READY_TO_ACCEPT_AUDIO_INPUT: 446 event[2] = HFP_SUBEVENT_ENHANCED_VOICE_RECOGNITION_AG_READY_TO_ACCEPT_AUDIO_INPUT; 447 break; 448 case HFP_VOICE_RECOGNITION_STATE_AG_IS_STARTING_SOUND: 449 event[2] = HFP_SUBEVENT_ENHANCED_VOICE_RECOGNITION_AG_IS_STARTING_SOUND; 450 break; 451 case HFP_VOICE_RECOGNITION_STATE_AG_IS_PROCESSING_AUDIO_INPUT: 452 event[2] = HFP_SUBEVENT_ENHANCED_VOICE_RECOGNITION_AG_IS_PROCESSING_AUDIO_INPUT; 453 break; 454 default: 455 btstack_unreachable(); 456 break; 457 } 458 459 little_endian_store_16(event, 3, acl_handle); 460 event[5] = status; 461 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 462 } 463 464 void hfp_emit_slc_connection_event(hfp_role_t local_role, uint8_t status, hci_con_handle_t con_handle, bd_addr_t addr){ 465 uint8_t event[12]; 466 int pos = 0; 467 event[pos++] = HCI_EVENT_HFP_META; 468 event[pos++] = sizeof(event) - 2; 469 event[pos++] = HFP_SUBEVENT_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 470 little_endian_store_16(event, pos, con_handle); 471 pos += 2; 472 event[pos++] = status; // status 0 == OK 473 reverse_bd_addr(addr,&event[pos]); 474 pos += 6; 475 hfp_emit_event_for_role(local_role, event, sizeof(event)); 476 } 477 478 static void hfp_emit_audio_connection_released(hfp_connection_t * hfp_connection, hci_con_handle_t sco_handle){ 479 btstack_assert(hfp_connection != NULL); 480 uint8_t event[7]; 481 int pos = 0; 482 event[pos++] = HCI_EVENT_HFP_META; 483 event[pos++] = sizeof(event) - 2; 484 event[pos++] = HFP_SUBEVENT_AUDIO_CONNECTION_RELEASED; 485 little_endian_store_16(event, pos, hfp_connection->acl_handle); 486 pos += 2; 487 little_endian_store_16(event, pos, sco_handle); 488 pos += 2; 489 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 490 } 491 492 void hfp_emit_sco_connection_established(hfp_connection_t *hfp_connection, uint8_t status, uint8_t negotiated_codec, 493 uint16_t rx_packet_length, uint16_t tx_packet_length) { 494 btstack_assert(hfp_connection != NULL); 495 uint8_t event[21]; 496 int pos = 0; 497 event[pos++] = HCI_EVENT_HFP_META; 498 event[pos++] = sizeof(event) - 2; 499 event[pos++] = HFP_SUBEVENT_AUDIO_CONNECTION_ESTABLISHED; 500 little_endian_store_16(event, pos, hfp_connection->acl_handle); 501 pos += 2; 502 event[pos++] = status; // status 0 == OK 503 little_endian_store_16(event, pos, hfp_connection->sco_handle); 504 pos += 2; 505 reverse_bd_addr(hfp_connection->remote_addr,&event[pos]); 506 pos += 6; 507 event[pos++] = negotiated_codec; 508 little_endian_store_16(event, pos, hfp_connection->packet_types); 509 pos += 2; 510 little_endian_store_16(event, pos, rx_packet_length); 511 pos += 2; 512 little_endian_store_16(event, pos, tx_packet_length); 513 pos += 2; 514 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 515 } 516 517 void hfp_emit_string_event(hfp_connection_t * hfp_connection, uint8_t event_subtype, const char * value){ 518 btstack_assert(hfp_connection != NULL); 519 #ifdef ENABLE_HFP_AT_MESSAGES 520 uint8_t event[256]; 521 #else 522 uint8_t event[40]; 523 #endif 524 uint16_t string_len = btstack_min((uint16_t) strlen(value), sizeof(event) - 6); 525 event[0] = HCI_EVENT_HFP_META; 526 event[1] = 4 + string_len; 527 event[2] = event_subtype; 528 little_endian_store_16(event, 3, hfp_connection->acl_handle); 529 memcpy((char*)&event[5], value, string_len); 530 event[5 + string_len] = 0; 531 hfp_emit_event_for_context(hfp_connection, event, 6 + string_len); 532 } 533 534 btstack_linked_list_t * hfp_get_connections(void){ 535 return (btstack_linked_list_t *) &hfp_connections; 536 } 537 538 hfp_connection_t * get_hfp_connection_context_for_rfcomm_cid(uint16_t cid){ 539 btstack_linked_list_iterator_t it; 540 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 541 while (btstack_linked_list_iterator_has_next(&it)){ 542 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 543 if (hfp_connection->rfcomm_cid == cid){ 544 return hfp_connection; 545 } 546 } 547 return NULL; 548 } 549 550 hfp_connection_t * get_hfp_connection_context_for_bd_addr(bd_addr_t bd_addr, hfp_role_t hfp_role){ 551 btstack_linked_list_iterator_t it; 552 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 553 while (btstack_linked_list_iterator_has_next(&it)){ 554 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 555 if ((memcmp(hfp_connection->remote_addr, bd_addr, 6) == 0) && (hfp_connection->local_role == hfp_role)) { 556 return hfp_connection; 557 } 558 } 559 return NULL; 560 } 561 562 hfp_connection_t * get_hfp_connection_context_for_sco_handle(uint16_t handle, hfp_role_t hfp_role){ 563 btstack_linked_list_iterator_t it; 564 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 565 while (btstack_linked_list_iterator_has_next(&it)){ 566 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 567 if ((hfp_connection->sco_handle == handle) && (hfp_connection->local_role == hfp_role)){ 568 return hfp_connection; 569 } 570 } 571 return NULL; 572 } 573 574 hfp_connection_t * get_hfp_connection_context_for_acl_handle(uint16_t handle, hfp_role_t hfp_role){ 575 btstack_linked_list_iterator_t it; 576 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 577 while (btstack_linked_list_iterator_has_next(&it)){ 578 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 579 if ((hfp_connection->acl_handle == handle) && (hfp_connection->local_role == hfp_role)){ 580 return hfp_connection; 581 } 582 } 583 return NULL; 584 } 585 586 587 static void hfp_reset_voice_recognition(hfp_connection_t * hfp_connection){ 588 btstack_assert(hfp_connection != NULL); 589 hfp_voice_recognition_activation_status_t current_vra_state = hfp_connection->vra_state; 590 hfp_connection->vra_state = HFP_VRA_VOICE_RECOGNITION_OFF; 591 592 if (current_vra_state != HFP_VRA_VOICE_RECOGNITION_OFF){ 593 hfp_emit_voice_recognition_disabled(hfp_connection, ERROR_CODE_SUCCESS); 594 } else if (hfp_connection->vra_state_requested != HFP_VRA_VOICE_RECOGNITION_OFF){ 595 hfp_emit_voice_recognition_disabled(hfp_connection, ERROR_CODE_SUCCESS); 596 } 597 598 hfp_connection->vra_state_requested = HFP_VRA_VOICE_RECOGNITION_OFF; 599 hfp_connection->activate_voice_recognition = false; 600 hfp_connection->deactivate_voice_recognition = false; 601 hfp_connection->enhanced_voice_recognition_enabled = false; 602 hfp_connection->ag_vra_status = 0; 603 hfp_connection->ag_vra_state = HFP_VOICE_RECOGNITION_STATE_AG_READY; 604 } 605 606 void hfp_reset_context_flags(hfp_connection_t * hfp_connection){ 607 if (!hfp_connection) return; 608 hfp_connection->ok_pending = 0; 609 hfp_connection->send_error = 0; 610 611 hfp_connection->found_equal_sign = false; 612 613 hfp_connection->change_status_update_for_individual_ag_indicators = 0; 614 hfp_connection->operator_name_changed = 0; 615 616 hfp_connection->enable_extended_audio_gateway_error_report = 0; 617 hfp_connection->extended_audio_gateway_error = 0; 618 619 // establish codecs hfp_connection 620 hfp_connection->suggested_codec = 0; 621 hfp_connection->negotiated_codec = 0; 622 hfp_connection->codec_confirmed = 0; 623 624 hfp_connection->establish_audio_connection = 0; 625 hfp_connection->call_waiting_notification_enabled = 0; 626 hfp_connection->command = HFP_CMD_NONE; 627 hfp_connection->enable_status_update_for_ag_indicators = 0xFF; 628 hfp_connection->clip_have_alpha = false; 629 hfp_reset_voice_recognition(hfp_connection); 630 } 631 632 static hfp_connection_t * create_hfp_connection_context(void){ 633 hfp_connection_t * hfp_connection = btstack_memory_hfp_connection_get(); 634 if (!hfp_connection) return NULL; 635 636 hfp_connection->state = HFP_IDLE; 637 hfp_connection->call_state = HFP_CALL_IDLE; 638 hfp_connection->codecs_state = HFP_CODECS_IDLE; 639 640 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 641 642 hfp_connection->acl_handle = HCI_CON_HANDLE_INVALID; 643 hfp_connection->sco_handle = HCI_CON_HANDLE_INVALID; 644 645 // HF only 646 hfp_connection->hf_call_status = HFP_CALL_STATUS_NO_HELD_OR_ACTIVE_CALLS; 647 hfp_connection->hf_callsetup_status = HFP_CALLSETUP_STATUS_NO_CALL_SETUP_IN_PROGRESS; 648 hfp_connection->hf_callheld_status = HFP_CALLHELD_STATUS_NO_CALLS_HELD; 649 650 hfp_reset_context_flags(hfp_connection); 651 652 btstack_linked_list_add_tail(&hfp_connections, (btstack_linked_item_t*)hfp_connection); 653 return hfp_connection; 654 } 655 656 void hfp_finalize_connection_context(hfp_connection_t * hfp_connection){ 657 btstack_linked_list_remove(&hfp_connections, (btstack_linked_item_t*) hfp_connection); 658 btstack_memory_hfp_connection_free(hfp_connection); 659 } 660 661 static hfp_connection_t * hfp_create_connection(bd_addr_t bd_addr, hfp_role_t local_role){ 662 hfp_connection_t * hfp_connection = get_hfp_connection_context_for_bd_addr(bd_addr, local_role); 663 if (hfp_connection) return hfp_connection; 664 hfp_connection = create_hfp_connection_context(); 665 if (!hfp_connection) { 666 return NULL; 667 } 668 (void)memcpy(hfp_connection->remote_addr, bd_addr, 6); 669 hfp_connection->local_role = local_role; 670 log_info("Create HFP context %p: role %u, addr %s", hfp_connection, local_role, bd_addr_to_str(bd_addr)); 671 672 #ifdef ENABLE_NXP_PCM_WBS 673 hfp_connection->nxp_start_audio_handle = HCI_CON_HANDLE_INVALID; 674 hfp_connection->nxp_stop_audio_handle = HCI_CON_HANDLE_INVALID; 675 #endif 676 677 return hfp_connection; 678 } 679 680 /* @param network. 681 * 0 == no ability to reject a call. 682 * 1 == ability to reject a call. 683 */ 684 685 /* @param suported_features 686 * HF bit 0: EC and/or NR function (yes/no, 1 = yes, 0 = no) 687 * HF bit 1: Call waiting or three-way calling(yes/no, 1 = yes, 0 = no) 688 * HF bit 2: CLI presentation capability (yes/no, 1 = yes, 0 = no) 689 * HF bit 3: Voice recognition activation (yes/no, 1= yes, 0 = no) 690 * HF bit 4: Remote volume control (yes/no, 1 = yes, 0 = no) 691 * HF bit 5: Wide band speech (yes/no, 1 = yes, 0 = no) 692 */ 693 /* Bit position: 694 * AG bit 0: Three-way calling (yes/no, 1 = yes, 0 = no) 695 * AG bit 1: EC and/or NR function (yes/no, 1 = yes, 0 = no) 696 * AG bit 2: Voice recognition function (yes/no, 1 = yes, 0 = no) 697 * AG bit 3: In-band ring tone capability (yes/no, 1 = yes, 0 = no) 698 * AG bit 4: Attach a phone number to a voice tag (yes/no, 1 = yes, 0 = no) 699 * AG bit 5: Wide band speech (yes/no, 1 = yes, 0 = no) 700 */ 701 702 void hfp_create_sdp_record(uint8_t * service, uint32_t service_record_handle, uint16_t service_uuid, int rfcomm_channel_nr, const char * name){ 703 uint8_t* attribute; 704 de_create_sequence(service); 705 706 // 0x0000 "Service Record Handle" 707 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_RECORD_HANDLE); 708 de_add_number(service, DE_UINT, DE_SIZE_32, service_record_handle); 709 710 // 0x0001 "Service Class ID List" 711 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST); 712 attribute = de_push_sequence(service); 713 { 714 // "UUID for Service" 715 de_add_number(attribute, DE_UUID, DE_SIZE_16, service_uuid); 716 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_GENERIC_AUDIO); 717 } 718 de_pop_sequence(service, attribute); 719 720 // 0x0004 "Protocol Descriptor List" 721 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST); 722 attribute = de_push_sequence(service); 723 { 724 uint8_t* l2cpProtocol = de_push_sequence(attribute); 725 { 726 de_add_number(l2cpProtocol, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_L2CAP); 727 } 728 de_pop_sequence(attribute, l2cpProtocol); 729 730 uint8_t* rfcomm = de_push_sequence(attribute); 731 { 732 de_add_number(rfcomm, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_RFCOMM); // rfcomm_service 733 de_add_number(rfcomm, DE_UINT, DE_SIZE_8, rfcomm_channel_nr); // rfcomm channel 734 } 735 de_pop_sequence(attribute, rfcomm); 736 } 737 de_pop_sequence(service, attribute); 738 739 740 // 0x0005 "Public Browse Group" 741 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BROWSE_GROUP_LIST); // public browse group 742 attribute = de_push_sequence(service); 743 { 744 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PUBLIC_BROWSE_ROOT); 745 } 746 de_pop_sequence(service, attribute); 747 748 // 0x0009 "Bluetooth Profile Descriptor List" 749 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BLUETOOTH_PROFILE_DESCRIPTOR_LIST); 750 attribute = de_push_sequence(service); 751 { 752 uint8_t *sppProfile = de_push_sequence(attribute); 753 { 754 de_add_number(sppProfile, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_HANDSFREE); 755 de_add_number(sppProfile, DE_UINT, DE_SIZE_16, 0x0109); // Version 1.9 756 } 757 de_pop_sequence(attribute, sppProfile); 758 } 759 de_pop_sequence(service, attribute); 760 761 // 0x0100 "Service Name" 762 if (strlen(name) > 0){ 763 de_add_number(service, DE_UINT, DE_SIZE_16, 0x0100); 764 de_add_data(service, DE_STRING, (uint16_t) strlen(name), (uint8_t *) name); 765 } 766 } 767 768 static void hfp_handle_slc_setup_error(hfp_connection_t * hfp_connection, uint8_t status){ 769 // cache fields for event 770 hfp_role_t local_role = hfp_connection->local_role; 771 bd_addr_t remote_addr; 772 // cppcheck-suppress uninitvar ; remote_addr is reported as uninitialized although it's the destination of the memcpy 773 (void)memcpy(remote_addr, hfp_connection->remote_addr, 6); 774 // finalize connection struct 775 hfp_finalize_connection_context(hfp_connection); 776 // emit event 777 hfp_emit_slc_connection_event(local_role, status, HCI_CON_HANDLE_INVALID, remote_addr); 778 } 779 780 static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 781 UNUSED(packet_type); // ok: handling own sdp events 782 UNUSED(channel); // ok: no channel 783 UNUSED(size); // ok: handling own sdp events 784 785 hfp_connection_t * hfp_connection = get_hfp_connection_context_for_bd_addr(hfp_sdp_query_context.remote_address, hfp_sdp_query_context.local_role); 786 if (hfp_connection == NULL) { 787 log_info("connection with %s and local role %d not found", hfp_sdp_query_context.remote_address, hfp_sdp_query_context.local_role); 788 return; 789 } 790 791 switch (hci_event_packet_get_type(packet)){ 792 case SDP_EVENT_QUERY_RFCOMM_SERVICE: 793 hfp_connection->rfcomm_channel_nr = sdp_event_query_rfcomm_service_get_rfcomm_channel(packet); 794 break; 795 case SDP_EVENT_QUERY_COMPLETE: 796 if (hfp_connection->rfcomm_channel_nr > 0){ 797 hfp_connection->state = HFP_W4_RFCOMM_CONNECTED; 798 btstack_packet_handler_t packet_handler; 799 switch (hfp_connection->local_role){ 800 case HFP_ROLE_AG: 801 packet_handler = hfp_ag_rfcomm_packet_handler; 802 break; 803 case HFP_ROLE_HF: 804 packet_handler = hfp_hf_rfcomm_packet_handler; 805 break; 806 default: 807 btstack_assert(false); 808 return; 809 } 810 811 rfcomm_create_channel(packet_handler, hfp_connection->remote_addr, hfp_connection->rfcomm_channel_nr, NULL); 812 813 } else { 814 uint8_t status = sdp_event_query_complete_get_status(packet); 815 if (status == ERROR_CODE_SUCCESS){ 816 // report service not found 817 status = SDP_SERVICE_NOT_FOUND; 818 } 819 hfp_handle_slc_setup_error(hfp_connection, status); 820 log_info("rfcomm service not found, status 0x%02x", status); 821 } 822 823 // register the SDP Query request to check if there is another connection waiting for the query 824 // ignore ERROR_CODE_COMMAND_DISALLOWED because in that case, we already have requested an SDP callback 825 (void) sdp_client_register_query_callback(&hfp_sdp_query_request); 826 break; 827 default: 828 break; 829 } 830 } 831 832 // returns 0 if unexpected error or no other link options remained, otherwise 1 833 static int hfp_handle_failed_sco_connection(uint8_t status){ 834 835 if (hfp_sco_establishment_active->accept_sco != 0){ 836 log_info("(e)SCO Connection failed but not started by us"); 837 return 0; 838 } 839 840 log_info("(e)SCO Connection failed 0x%02x", status); 841 switch (status){ 842 case ERROR_CODE_INVALID_LMP_PARAMETERS_INVALID_LL_PARAMETERS: 843 case ERROR_CODE_SCO_AIR_MODE_REJECTED: 844 case ERROR_CODE_SCO_INTERVAL_REJECTED: 845 case ERROR_CODE_SCO_OFFSET_REJECTED: 846 case ERROR_CODE_UNSPECIFIED_ERROR: 847 case ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE: 848 case ERROR_CODE_UNSUPPORTED_LMP_PARAMETER_VALUE_UNSUPPORTED_LL_PARAMETER_VALUE: 849 case ERROR_CODE_UNSUPPORTED_REMOTE_FEATURE_UNSUPPORTED_LMP_FEATURE: 850 break; 851 default: 852 return 0; 853 } 854 855 // note: eSCO_S4 supported flag not available, but it's only relevant for highest CVSD link setting (and the current failed) 856 hfp_link_settings_t next_setting = hfp_next_link_setting_for_connection(hfp_sco_establishment_active->link_setting, hfp_sco_establishment_active, false); 857 858 // handle no valid setting found 859 if (next_setting == HFP_LINK_SETTINGS_NONE) { 860 if (hfp_sco_establishment_active->negotiated_codec == HFP_CODEC_MSBC){ 861 log_info("T2/T1 failed, fallback to CVSD - D1"); 862 hfp_sco_establishment_active->negotiated_codec = HFP_CODEC_CVSD; 863 hfp_sco_establishment_active->sco_for_msbc_failed = 1; 864 hfp_sco_establishment_active->ag_send_common_codec = true; 865 hfp_sco_establishment_active->link_setting = HFP_LINK_SETTINGS_D1; 866 } else { 867 // no other options 868 return 0; 869 } 870 } 871 872 log_info("e)SCO Connection: try new link_setting %d", next_setting); 873 hfp_sco_establishment_active->establish_audio_connection = 1; 874 hfp_sco_establishment_active->link_setting = next_setting; 875 hfp_sco_establishment_active->accept_sco = 0; 876 hfp_sco_establishment_active = NULL; 877 return 1; 878 } 879 880 void hfp_handle_hci_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size, hfp_role_t local_role){ 881 UNUSED(packet_type); 882 UNUSED(channel); // ok: no channel 883 UNUSED(size); 884 885 bd_addr_t event_addr; 886 hci_con_handle_t handle; 887 hfp_connection_t * hfp_connection = NULL; 888 uint8_t status; 889 890 log_debug("HFP HCI event handler type %u, event type %x, size %u", packet_type, hci_event_packet_get_type(packet), size); 891 892 switch (hci_event_packet_get_type(packet)) { 893 894 case HCI_EVENT_CONNECTION_REQUEST: 895 switch(hci_event_connection_request_get_link_type(packet)){ 896 case 0: // SCO 897 case 2: // eSCO 898 hci_event_connection_request_get_bd_addr(packet, event_addr); 899 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 900 if (!hfp_connection) break; 901 if (hci_event_connection_request_get_link_type(packet) == 2){ 902 hfp_connection->accept_sco = 2; 903 } else { 904 hfp_connection->accept_sco = 1; 905 } 906 // configure SBC coded if needed 907 hfp_prepare_for_sco(hfp_connection); 908 log_info("accept sco %u\n", hfp_connection->accept_sco); 909 break; 910 default: 911 break; 912 } 913 break; 914 915 case HCI_EVENT_COMMAND_STATUS: 916 if (hci_event_command_status_get_command_opcode(packet) == hci_setup_synchronous_connection.opcode) { 917 if (hfp_sco_establishment_active == NULL) break; 918 status = hci_event_command_status_get_status(packet); 919 if (status == ERROR_CODE_SUCCESS) break; 920 921 hfp_connection = hfp_sco_establishment_active; 922 if (hfp_handle_failed_sco_connection(status)) break; 923 924 hfp_connection->accept_sco = 0; 925 hfp_connection->establish_audio_connection = 0; 926 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 927 hfp_sco_establishment_active = NULL; 928 hfp_emit_sco_connection_established(hfp_connection, status, 929 hfp_connection->negotiated_codec, 0, 0); 930 } 931 break; 932 933 case HCI_EVENT_SYNCHRONOUS_CONNECTION_COMPLETE:{ 934 if (hfp_sco_establishment_active == NULL) break; 935 936 hfp_connection = hfp_sco_establishment_active; 937 938 status = hci_event_synchronous_connection_complete_get_status(packet); 939 if (status != ERROR_CODE_SUCCESS){ 940 if (hfp_handle_failed_sco_connection(status)) break; 941 942 hfp_connection->accept_sco = 0; 943 hfp_connection->establish_audio_connection = 0; 944 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 945 hfp_sco_establishment_active = NULL; 946 hfp_emit_sco_connection_established(hfp_connection, status, 947 hfp_connection->negotiated_codec, 0, 0); 948 break; 949 } 950 951 uint16_t sco_handle = hci_event_synchronous_connection_complete_get_handle(packet); 952 uint8_t link_type = hci_event_synchronous_connection_complete_get_link_type(packet); 953 uint8_t transmission_interval = hci_event_synchronous_connection_complete_get_transmission_interval(packet); // measured in slots 954 uint8_t retransmission_interval = hci_event_synchronous_connection_complete_get_retransmission_interval(packet);// measured in slots 955 uint16_t rx_packet_length = hci_event_synchronous_connection_complete_get_rx_packet_length(packet); // measured in bytes 956 uint16_t tx_packet_length = hci_event_synchronous_connection_complete_get_tx_packet_length(packet); // measured in bytes 957 958 switch (link_type){ 959 case 0x00: 960 log_info("SCO Connection established."); 961 if (transmission_interval != 0) log_error("SCO Connection: transmission_interval not zero: %d.", transmission_interval); 962 if (retransmission_interval != 0) log_error("SCO Connection: retransmission_interval not zero: %d.", retransmission_interval); 963 if (rx_packet_length != 0) log_error("SCO Connection: rx_packet_length not zero: %d.", rx_packet_length); 964 if (tx_packet_length != 0) log_error("SCO Connection: tx_packet_length not zero: %d.", tx_packet_length); 965 break; 966 case 0x02: 967 log_info("eSCO Connection established. \n"); 968 break; 969 default: 970 log_error("(e)SCO reserved link_type 0x%2x", link_type); 971 break; 972 } 973 974 log_info("sco_handle 0x%2x, address %s, transmission_interval %u slots, retransmission_interval %u slots, " 975 " rx_packet_length %u bytes, tx_packet_length %u bytes, air_mode 0x%2x (0x02 == CVSD)\n", sco_handle, 976 bd_addr_to_str(event_addr), transmission_interval, retransmission_interval, rx_packet_length, tx_packet_length, 977 hci_event_synchronous_connection_complete_get_air_mode(packet)); 978 979 if (hfp_connection->state == HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN){ 980 log_info("SCO about to disconnect: HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN"); 981 hfp_connection->state = HFP_W2_DISCONNECT_SCO; 982 break; 983 } 984 hfp_connection->sco_handle = sco_handle; 985 hfp_connection->accept_sco = 0; 986 hfp_connection->establish_audio_connection = 0; 987 988 hfp_connection->state = HFP_AUDIO_CONNECTION_ESTABLISHED; 989 990 switch (hfp_connection->vra_state){ 991 case HFP_VRA_VOICE_RECOGNITION_ACTIVATED: 992 hfp_connection->ag_audio_connection_opened_before_vra = false; 993 break; 994 default: 995 hfp_connection->ag_audio_connection_opened_before_vra = true; 996 break; 997 } 998 999 hfp_sco_establishment_active = NULL; 1000 1001 hfp_emit_sco_connection_established(hfp_connection, status, 1002 hfp_connection->negotiated_codec, rx_packet_length, tx_packet_length); 1003 1004 #ifdef ENABLE_NXP_PCM_WBS 1005 hfp_connection->nxp_start_audio_handle = hfp_connection->sco_handle; 1006 #endif 1007 break; 1008 } 1009 1010 case HCI_EVENT_DISCONNECTION_COMPLETE: 1011 handle = little_endian_read_16(packet,3); 1012 hfp_connection = get_hfp_connection_context_for_sco_handle(handle, local_role); 1013 1014 if (!hfp_connection) break; 1015 1016 #ifdef ENABLE_CC256X_ASSISTED_HFP 1017 hfp_connection->cc256x_send_wbs_disassociate = true; 1018 #endif 1019 #ifdef ENABLE_BCM_PCM_WBS 1020 hfp_connection->bcm_send_disable_wbs = true; 1021 #endif 1022 #ifdef ENABLE_NXP_PCM_WBS 1023 hfp_connection->nxp_stop_audio_handle = hfp_connection->sco_handle; 1024 #endif 1025 1026 if (hfp_connection->sco_handle == handle){ 1027 hfp_connection->sco_handle = HCI_CON_HANDLE_INVALID; 1028 hfp_connection->release_audio_connection = 0; 1029 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 1030 hfp_emit_audio_connection_released(hfp_connection, handle); 1031 1032 hfp_connection->ag_audio_connection_opened_before_vra = false; 1033 1034 if (hfp_connection->acl_handle == HCI_CON_HANDLE_INVALID){ 1035 hfp_reset_voice_recognition(hfp_connection); 1036 hfp_emit_event(hfp_connection, HFP_SUBEVENT_SERVICE_LEVEL_CONNECTION_RELEASED, 0); 1037 hfp_finalize_connection_context(hfp_connection); 1038 break; 1039 } else if (hfp_connection->release_slc_connection == 1){ 1040 hfp_connection->release_slc_connection = 0; 1041 hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM; 1042 rfcomm_disconnect(hfp_connection->acl_handle); 1043 } 1044 } 1045 1046 if (hfp_connection->state == HFP_W4_SCO_DISCONNECTED_TO_SHUTDOWN){ 1047 // RFCOMM already closed -> remote power off 1048 #if defined(ENABLE_CC256X_ASSISTED_HFP) || defined (ENABLE_BCM_PCM_WBS) 1049 hfp_connection->state = HFP_W4_WBS_SHUTDOWN; 1050 #else 1051 hfp_finalize_connection_context(hfp_connection); 1052 #endif 1053 break; 1054 } 1055 break; 1056 1057 default: 1058 break; 1059 } 1060 } 1061 1062 1063 void hfp_handle_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size, hfp_role_t local_role){ 1064 UNUSED(packet_type); 1065 UNUSED(channel); // ok: no channel 1066 UNUSED(size); 1067 1068 bd_addr_t event_addr; 1069 uint16_t rfcomm_cid; 1070 hfp_connection_t * hfp_connection = NULL; 1071 uint8_t status; 1072 1073 log_debug("HFP packet_handler type %u, event type %x, size %u", packet_type, hci_event_packet_get_type(packet), size); 1074 1075 switch (hci_event_packet_get_type(packet)) { 1076 1077 case RFCOMM_EVENT_INCOMING_CONNECTION: 1078 // data: event (8), len(8), address(48), channel (8), rfcomm_cid (16) 1079 rfcomm_event_incoming_connection_get_bd_addr(packet, event_addr); 1080 hfp_connection = hfp_create_connection(event_addr, local_role); 1081 if (!hfp_connection){ 1082 log_info("hfp: no memory to accept incoming connection - decline"); 1083 rfcomm_decline_connection(rfcomm_event_incoming_connection_get_rfcomm_cid(packet)); 1084 return; 1085 } 1086 if (hfp_connection->state != HFP_IDLE) { 1087 log_error("hfp: incoming connection but not idle, reject"); 1088 rfcomm_decline_connection(rfcomm_event_incoming_connection_get_rfcomm_cid(packet)); 1089 return; 1090 } 1091 1092 hfp_connection->rfcomm_cid = rfcomm_event_incoming_connection_get_rfcomm_cid(packet); 1093 hfp_connection->state = HFP_W4_RFCOMM_CONNECTED; 1094 rfcomm_accept_connection(hfp_connection->rfcomm_cid); 1095 break; 1096 1097 case RFCOMM_EVENT_CHANNEL_OPENED: 1098 rfcomm_event_channel_opened_get_bd_addr(packet, event_addr); 1099 1100 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 1101 btstack_assert(hfp_connection != NULL); 1102 1103 if (hfp_connection->state != HFP_W4_RFCOMM_CONNECTED){ 1104 break; 1105 } 1106 1107 status = rfcomm_event_channel_opened_get_status(packet); 1108 if (status != ERROR_CODE_SUCCESS) { 1109 hfp_handle_slc_setup_error(hfp_connection, status); 1110 break; 1111 } 1112 1113 hfp_connection->acl_handle = rfcomm_event_channel_opened_get_con_handle(packet); 1114 hfp_connection->rfcomm_cid = rfcomm_event_channel_opened_get_rfcomm_cid(packet); 1115 hfp_connection->rfcomm_mtu = rfcomm_event_channel_opened_get_max_frame_size(packet); 1116 bd_addr_copy(hfp_connection->remote_addr, event_addr); 1117 hfp_connection->state = HFP_EXCHANGE_SUPPORTED_FEATURES; 1118 1119 rfcomm_request_can_send_now_event(hfp_connection->rfcomm_cid); 1120 break; 1121 1122 case RFCOMM_EVENT_CHANNEL_CLOSED: 1123 rfcomm_cid = little_endian_read_16(packet,2); 1124 hfp_connection = get_hfp_connection_context_for_rfcomm_cid(rfcomm_cid); 1125 if (!hfp_connection) break; 1126 switch (hfp_connection->state){ 1127 case HFP_W4_RFCOMM_DISCONNECTED_AND_RESTART: 1128 hfp_connection->acl_handle = HCI_CON_HANDLE_INVALID; 1129 hfp_connection->state = HFP_IDLE; 1130 hfp_establish_service_level_connection(hfp_connection->remote_addr, hfp_connection->service_uuid, local_role); 1131 break; 1132 1133 case HFP_AUDIO_CONNECTION_ESTABLISHED: 1134 // service connection was released, this implicitly releases audio connection as well 1135 hfp_connection->release_audio_connection = 0; 1136 hfp_connection->acl_handle = HCI_CON_HANDLE_INVALID; 1137 hfp_connection->state = HFP_W4_SCO_DISCONNECTED_TO_SHUTDOWN; 1138 gap_disconnect(hfp_connection->sco_handle); 1139 break; 1140 1141 default: 1142 // regular case 1143 hfp_reset_voice_recognition(hfp_connection); 1144 hfp_emit_event(hfp_connection, HFP_SUBEVENT_SERVICE_LEVEL_CONNECTION_RELEASED, 0); 1145 hfp_finalize_connection_context(hfp_connection); 1146 break; 1147 } 1148 break; 1149 1150 default: 1151 break; 1152 } 1153 } 1154 // translates command string into hfp_command_t CMD 1155 1156 typedef struct { 1157 const char * command; 1158 hfp_command_t command_id; 1159 } hfp_command_entry_t; 1160 1161 static hfp_command_entry_t hfp_ag_command_table[] = { 1162 { "AT+BAC=", HFP_CMD_AVAILABLE_CODECS }, 1163 { "AT+BCC", HFP_CMD_TRIGGER_CODEC_CONNECTION_SETUP }, 1164 { "AT+BCS=", HFP_CMD_HF_CONFIRMED_CODEC }, 1165 { "AT+BIA=", HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE, }, // +BIA:<enabled>,,<enabled>,,,<enabled> 1166 { "AT+BIEV=", HFP_CMD_HF_INDICATOR_STATUS }, 1167 { "AT+BIND=", HFP_CMD_LIST_GENERIC_STATUS_INDICATORS }, 1168 { "AT+BIND=?", HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS }, 1169 { "AT+BIND?", HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE }, 1170 { "AT+BINP=", HFP_CMD_HF_REQUEST_PHONE_NUMBER }, 1171 { "AT+BLDN", HFP_CMD_REDIAL_LAST_NUMBER }, 1172 { "AT+BRSF=", HFP_CMD_SUPPORTED_FEATURES }, 1173 { "AT+BTRH=", HFP_CMD_RESPONSE_AND_HOLD_COMMAND }, 1174 { "AT+BTRH?", HFP_CMD_RESPONSE_AND_HOLD_QUERY }, 1175 { "AT+BVRA=", HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION }, 1176 { "AT+CCWA=", HFP_CMD_ENABLE_CALL_WAITING_NOTIFICATION}, 1177 { "AT+CHLD=", HFP_CMD_CALL_HOLD }, 1178 { "AT+CHLD=?", HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES }, 1179 { "AT+CHUP", HFP_CMD_HANG_UP_CALL }, 1180 { "AT+CIND=?", HFP_CMD_RETRIEVE_AG_INDICATORS }, 1181 { "AT+CIND?", HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS }, 1182 { "AT+CLCC", HFP_CMD_LIST_CURRENT_CALLS }, 1183 { "AT+CLIP=", HFP_CMD_ENABLE_CLIP}, 1184 { "AT+CMEE=", HFP_CMD_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR}, 1185 { "AT+CMER=", HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE }, 1186 { "AT+CNUM", HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION }, 1187 { "AT+COPS=", HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT }, 1188 { "AT+COPS?", HFP_CMD_QUERY_OPERATOR_SELECTION_NAME }, 1189 { "AT+NREC=", HFP_CMD_TURN_OFF_EC_AND_NR, }, 1190 { "AT+VGM=", HFP_CMD_SET_MICROPHONE_GAIN }, 1191 { "AT+VGS=", HFP_CMD_SET_SPEAKER_GAIN }, 1192 { "AT+VTS=", HFP_CMD_TRANSMIT_DTMF_CODES }, 1193 { "ATA", HFP_CMD_CALL_ANSWERED }, 1194 }; 1195 1196 static hfp_command_entry_t hfp_hf_command_table[] = { 1197 { "+BCS:", HFP_CMD_AG_SUGGESTED_CODEC }, 1198 { "+BIND:", HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS }, 1199 { "+BINP:", HFP_CMD_AG_SENT_PHONE_NUMBER }, 1200 { "+BRSF:", HFP_CMD_SUPPORTED_FEATURES }, 1201 { "+BSIR:", HFP_CMD_CHANGE_IN_BAND_RING_TONE_SETTING }, 1202 { "+BTRH:", HFP_CMD_RESPONSE_AND_HOLD_STATUS }, 1203 { "+BVRA:", HFP_CMD_AG_ACTIVATE_VOICE_RECOGNITION }, 1204 { "+CCWA:", HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE, }, 1205 { "+CHLD:", HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES }, 1206 { "+CIEV:", HFP_CMD_TRANSFER_AG_INDICATOR_STATUS}, 1207 { "+CIND:", HFP_CMD_RETRIEVE_AG_INDICATORS_GENERIC }, 1208 { "+CLCC:", HFP_CMD_LIST_CURRENT_CALLS }, 1209 { "+CLIP:", HFP_CMD_AG_SENT_CLIP_INFORMATION }, 1210 { "+CME ERROR:", HFP_CMD_EXTENDED_AUDIO_GATEWAY_ERROR }, 1211 { "+CNUM:", HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION}, 1212 { "+COPS:", HFP_CMD_QUERY_OPERATOR_SELECTION_NAME }, 1213 { "+VGM:", HFP_CMD_SET_MICROPHONE_GAIN }, 1214 { "+VGM=", HFP_CMD_SET_MICROPHONE_GAIN }, 1215 { "+VGS:", HFP_CMD_SET_SPEAKER_GAIN}, 1216 { "+VGS=", HFP_CMD_SET_SPEAKER_GAIN}, 1217 { "ERROR", HFP_CMD_ERROR}, 1218 { "NOP", HFP_CMD_NONE}, // dummy command used by unit tests 1219 { "OK", HFP_CMD_OK }, 1220 { "RING", HFP_CMD_RING }, 1221 }; 1222 1223 static const hfp_custom_at_command_t * 1224 hfp_custom_command_lookup(bool isHandsFree, const char *text) { 1225 btstack_linked_list_t * custom_commands = isHandsFree ? &hfp_custom_commands_hf : &hfp_custom_commands_ag; 1226 btstack_linked_list_iterator_t it; 1227 btstack_linked_list_iterator_init(&it, custom_commands); 1228 while (btstack_linked_list_iterator_has_next(&it)) { 1229 hfp_custom_at_command_t *at_command = (hfp_custom_at_command_t *) btstack_linked_list_iterator_next(&it); 1230 int match = strcmp(text, at_command->command); 1231 if (match == 0) { 1232 return at_command; 1233 } 1234 } 1235 return NULL; 1236 } 1237 1238 static hfp_command_t parse_command(const char * line_buffer, int isHandsFree){ 1239 1240 // check for custom commands, AG only 1241 const hfp_custom_at_command_t * custom_at_command = hfp_custom_command_lookup(isHandsFree, line_buffer); 1242 if (custom_at_command != NULL){ 1243 return HFP_CMD_CUSTOM_MESSAGE; 1244 } 1245 1246 // table lookup based on role 1247 uint16_t num_entries; 1248 hfp_command_entry_t * table; 1249 if (isHandsFree == 0){ 1250 table = hfp_ag_command_table; 1251 num_entries = sizeof(hfp_ag_command_table) / sizeof(hfp_command_entry_t); 1252 } else { 1253 table = hfp_hf_command_table; 1254 num_entries = sizeof(hfp_hf_command_table) / sizeof(hfp_command_entry_t); 1255 } 1256 // binary search 1257 uint16_t left = 0; 1258 uint16_t right = num_entries - 1; 1259 while (left <= right){ 1260 uint16_t middle = left + (right - left) / 2; 1261 hfp_command_entry_t *entry = &table[middle]; 1262 int match = strcmp(line_buffer, entry->command); 1263 if (match < 0){ 1264 // search term is lower than middle element 1265 if (middle == 0) break; 1266 right = middle - 1; 1267 } else if (match == 0){ 1268 return entry->command_id; 1269 } else { 1270 // search term is higher than middle element 1271 left = middle + 1; 1272 } 1273 } 1274 1275 // note: if parser in CMD_HEADER state would treats digits and maybe '+' as separator, match on "ATD" would work. 1276 // note: phone number is currently expected in line_buffer[3..] 1277 // prefix match on 'ATD', AG only 1278 if ((isHandsFree == 0) && (strncmp(line_buffer, HFP_CALL_PHONE_NUMBER, strlen(HFP_CALL_PHONE_NUMBER)) == 0)){ 1279 return HFP_CMD_CALL_PHONE_NUMBER; 1280 } 1281 1282 // Valid looking, but unknown commands/responses 1283 if ((isHandsFree == 0) && (strncmp(line_buffer, "AT+", 3) == 0)){ 1284 return HFP_CMD_UNKNOWN; 1285 } 1286 1287 if ((isHandsFree != 0) && (strncmp(line_buffer, "+", 1) == 0)){ 1288 return HFP_CMD_UNKNOWN; 1289 } 1290 1291 return HFP_CMD_NONE; 1292 } 1293 1294 static void hfp_parser_store_byte(hfp_connection_t * hfp_connection, uint8_t byte){ 1295 if ((hfp_connection->line_size + 1) >= HFP_MAX_VR_TEXT_SIZE) return; 1296 hfp_connection->line_buffer[hfp_connection->line_size++] = byte; 1297 hfp_connection->line_buffer[hfp_connection->line_size] = 0; 1298 } 1299 static int hfp_parser_is_buffer_empty(hfp_connection_t * hfp_connection){ 1300 return hfp_connection->line_size == 0; 1301 } 1302 1303 static int hfp_parser_is_end_of_line(uint8_t byte){ 1304 return (byte == '\n') || (byte == '\r'); 1305 } 1306 1307 void hfp_parser_reset_line_buffer(hfp_connection_t *hfp_connection) { 1308 hfp_connection->line_size = 0; 1309 // we don't set the first byte to '\0' to allow access to last argument e.g. in hfp_hf_handle_rfcommand 1310 } 1311 1312 static void hfp_parser_store_if_token(hfp_connection_t * hfp_connection, uint8_t byte){ 1313 switch (byte){ 1314 case ',': 1315 case '-': 1316 case ';': 1317 case '(': 1318 case ')': 1319 case '\n': 1320 case '\r': 1321 break; 1322 default: 1323 hfp_parser_store_byte(hfp_connection, byte); 1324 break; 1325 } 1326 } 1327 1328 static bool hfp_parser_is_separator( uint8_t byte){ 1329 switch (byte){ 1330 case ',': 1331 case '-': 1332 case ';': 1333 case '\n': 1334 case '\r': 1335 return true; 1336 default: 1337 return false; 1338 } 1339 } 1340 1341 // returns true if received bytes was processed. Otherwise, functions will be called with same byte again 1342 // this is used to for a one byte lookahead, where an unexpected byte is pushed back by returning false 1343 static bool hfp_parse_byte(hfp_connection_t * hfp_connection, uint8_t byte, int isHandsFree){ 1344 1345 #ifdef HFP_DEBUG 1346 if (byte >= ' '){ 1347 printf("Parse '%c' - state %u, buffer %s\n", byte, hfp_connection->parser_state, hfp_connection->line_buffer); 1348 } else { 1349 printf("Parse 0x%02x - state %u, buffer %s\n", byte, hfp_connection->parser_state, hfp_connection->line_buffer); 1350 } 1351 #endif 1352 1353 // handle doubles quotes 1354 if (byte == '"'){ 1355 hfp_connection->parser_quoted = !hfp_connection->parser_quoted; 1356 return true; 1357 } 1358 if (hfp_connection->parser_quoted) { 1359 hfp_parser_store_byte(hfp_connection, byte); 1360 return true; 1361 } 1362 1363 // ignore spaces outside command or double quotes (required e.g. for '+CME ERROR:..") command 1364 if ((byte == ' ') && (hfp_connection->parser_state != HFP_PARSER_CMD_HEADER)) return true; 1365 1366 bool processed = true; 1367 1368 switch (hfp_connection->parser_state) { 1369 case HFP_PARSER_CMD_HEADER: 1370 switch (byte) { 1371 case '\n': 1372 case '\r': 1373 case ';': 1374 // ignore separator 1375 break; 1376 case ':': 1377 case '?': 1378 // store separator 1379 hfp_parser_store_byte(hfp_connection, byte); 1380 break; 1381 case '=': 1382 // equal sign: remember and wait for next char to decided between '=?' and '=\?' 1383 hfp_connection->found_equal_sign = true; 1384 hfp_parser_store_byte(hfp_connection, byte); 1385 return true; 1386 default: 1387 // store if not lookahead 1388 if (!hfp_connection->found_equal_sign) { 1389 hfp_parser_store_byte(hfp_connection, byte); 1390 return true; 1391 } 1392 // mark as lookahead 1393 processed = false; 1394 break; 1395 } 1396 1397 // ignore empty tokens 1398 if (hfp_parser_is_buffer_empty(hfp_connection)) return true; 1399 1400 // parse 1401 hfp_connection->command = parse_command((char *)hfp_connection->line_buffer, isHandsFree); 1402 1403 // pick +CIND version based on connection state: descriptions during SLC vs. states later 1404 if (hfp_connection->command == HFP_CMD_RETRIEVE_AG_INDICATORS_GENERIC){ 1405 switch(hfp_connection->state){ 1406 case HFP_W4_RETRIEVE_INDICATORS_STATUS: 1407 hfp_connection->command = HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS; 1408 break; 1409 case HFP_W4_RETRIEVE_INDICATORS: 1410 hfp_connection->command = HFP_CMD_RETRIEVE_AG_INDICATORS; 1411 break; 1412 default: 1413 hfp_connection->command = HFP_CMD_UNKNOWN; 1414 break; 1415 } 1416 } 1417 1418 log_info("command string '%s', handsfree %u -> cmd id %u", (char *)hfp_connection->line_buffer, isHandsFree, hfp_connection->command); 1419 1420 // store command id for custom command and just store rest of line 1421 if (hfp_connection->command == HFP_CMD_CUSTOM_MESSAGE){ 1422 const hfp_custom_at_command_t * at_command = hfp_custom_command_lookup(isHandsFree, (const char *) hfp_connection->line_buffer); 1423 hfp_connection->custom_at_command_id = at_command->command_id; 1424 hfp_connection->parser_state = HFP_PARSER_CUSTOM_COMMAND; 1425 return processed; 1426 } 1427 1428 // next state 1429 hfp_parser_reset_line_buffer(hfp_connection); 1430 hfp_connection->parser_state = HFP_PARSER_CMD_SEQUENCE; 1431 1432 return processed; 1433 1434 case HFP_PARSER_CMD_SEQUENCE: 1435 // handle empty fields 1436 if ((byte == ',' ) && (hfp_connection->line_size == 0)){ 1437 hfp_connection->line_buffer[0] = 0; 1438 hfp_connection->ignore_value = 1; 1439 parse_sequence(hfp_connection); 1440 return true; 1441 } 1442 1443 hfp_parser_store_if_token(hfp_connection, byte); 1444 if (!hfp_parser_is_separator(byte)) return true; 1445 1446 // ignore empty tokens 1447 switch (hfp_connection->command){ 1448 case HFP_CMD_AG_ACTIVATE_VOICE_RECOGNITION: 1449 // don't ignore empty string 1450 break; 1451 default: 1452 if (hfp_parser_is_buffer_empty(hfp_connection) && (hfp_connection->ignore_value == 0)) { 1453 return true; 1454 } 1455 break; 1456 } 1457 1458 parse_sequence(hfp_connection); 1459 1460 hfp_parser_reset_line_buffer(hfp_connection); 1461 1462 switch (hfp_connection->command){ 1463 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1464 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1465 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1466 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1467 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1468 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1469 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1470 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1471 case HFP_CMD_HF_INDICATOR_STATUS: 1472 hfp_connection->parser_state = HFP_PARSER_SECOND_ITEM; 1473 break; 1474 default: 1475 break; 1476 } 1477 return true; 1478 1479 case HFP_PARSER_SECOND_ITEM: 1480 1481 hfp_parser_store_if_token(hfp_connection, byte); 1482 if (!hfp_parser_is_separator(byte)) return true; 1483 1484 switch (hfp_connection->command){ 1485 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1486 log_info("format %s, ", hfp_connection->line_buffer); 1487 hfp_connection->network_operator.format = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1488 break; 1489 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1490 log_info("format %s \n", hfp_connection->line_buffer); 1491 hfp_connection->network_operator.format = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1492 break; 1493 case HFP_CMD_LIST_GENERIC_STATUS_INDICATORS: 1494 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS: 1495 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1496 hfp_connection->generic_status_indicators[hfp_connection->parser_item_index].state = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1497 break; 1498 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1499 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1500 log_info("%d \n", hfp_connection->ag_indicators[hfp_connection->parser_item_index].status); 1501 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status_changed = 1; 1502 break; 1503 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1504 hfp_connection->ag_indicators[hfp_connection->parser_item_index].min_range = btstack_atoi((char *)hfp_connection->line_buffer); 1505 log_info("%s, ", hfp_connection->line_buffer); 1506 break; 1507 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1508 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1509 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1510 hfp_connection->bnip_type = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1511 break; 1512 case HFP_CMD_HF_INDICATOR_STATUS: 1513 hfp_connection->parser_indicator_value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1514 break; 1515 default: 1516 break; 1517 } 1518 1519 hfp_parser_reset_line_buffer(hfp_connection); 1520 1521 hfp_connection->parser_state = HFP_PARSER_THIRD_ITEM; 1522 1523 return true; 1524 1525 case HFP_PARSER_THIRD_ITEM: 1526 1527 hfp_parser_store_if_token(hfp_connection, byte); 1528 if (!hfp_parser_is_separator(byte)) return true; 1529 1530 switch (hfp_connection->command){ 1531 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1532 btstack_strcpy(hfp_connection->network_operator.name, HFP_MAX_NETWORK_OPERATOR_NAME_SIZE, (char *)hfp_connection->line_buffer); 1533 break; 1534 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1535 hfp_connection->ag_indicators[hfp_connection->parser_item_index].max_range = btstack_atoi((char *)hfp_connection->line_buffer); 1536 hfp_next_indicators_index(hfp_connection); 1537 hfp_connection->ag_indicators_nr = hfp_connection->parser_item_index; 1538 break; 1539 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1540 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1541 // track if last argument exists 1542 hfp_connection->clip_have_alpha = hfp_connection->line_size != 0; 1543 break; 1544 default: 1545 break; 1546 } 1547 1548 hfp_parser_reset_line_buffer(hfp_connection); 1549 1550 if (hfp_connection->command == HFP_CMD_RETRIEVE_AG_INDICATORS){ 1551 hfp_connection->parser_state = HFP_PARSER_CMD_SEQUENCE; 1552 } 1553 return true; 1554 1555 case HFP_PARSER_CUSTOM_COMMAND: 1556 if (hfp_parser_is_end_of_line(byte) == false){ 1557 hfp_parser_store_byte(hfp_connection, byte); 1558 } 1559 return true; 1560 1561 default: 1562 btstack_assert(false); 1563 return true; 1564 } 1565 } 1566 1567 void hfp_parse(hfp_connection_t * hfp_connection, uint8_t byte, int isHandsFree){ 1568 bool processed = false; 1569 while (!processed){ 1570 processed = hfp_parse_byte(hfp_connection, byte, isHandsFree); 1571 } 1572 // reset parser state on end-of-line 1573 if (hfp_parser_is_end_of_line(byte)){ 1574 hfp_connection->found_equal_sign = false; 1575 hfp_connection->parser_item_index = 0; 1576 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 1577 } 1578 } 1579 1580 static void parse_sequence(hfp_connection_t * hfp_connection){ 1581 int value; 1582 switch (hfp_connection->command){ 1583 case HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS: 1584 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1585 int i; 1586 switch (hfp_connection->parser_item_index){ 1587 case 0: 1588 for (i=0;i<hfp_connection->generic_status_indicators_nr;i++){ 1589 if (hfp_connection->generic_status_indicators[i].uuid == value){ 1590 hfp_connection->parser_indicator_index = i; 1591 break; 1592 } 1593 } 1594 break; 1595 case 1: 1596 if (hfp_connection->parser_indicator_index <0) break; 1597 hfp_connection->generic_status_indicators[hfp_connection->parser_indicator_index].state = value; 1598 log_info("HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS set indicator at index %u, to %u\n", 1599 hfp_connection->parser_item_index, value); 1600 break; 1601 default: 1602 break; 1603 } 1604 hfp_next_indicators_index(hfp_connection); 1605 break; 1606 1607 case HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION: 1608 switch(hfp_connection->parser_item_index){ 1609 case 0: 1610 // <alpha>: This optional field is not supported, and shall be left blank. 1611 break; 1612 case 1: 1613 // <number>: Quoted string containing the phone number in the format specified by <type>. 1614 btstack_strcpy(hfp_connection->bnip_number, sizeof(hfp_connection->bnip_number), (char *)hfp_connection->line_buffer); 1615 break; 1616 case 2: 1617 /* 1618 <type> field specifies the format of the phone number provided, and can be one of the following values: 1619 - values 128-143: The phone number format may be a national or international format, and may contain prefix and/or escape digits. No changes on the number presentation are required. 1620 - values 144-159: The phone number format is an international number, including the country code prefix. If the plus sign ("+") is not included as part of the number and shall be added by the AG as needed. 1621 - values 160-175: National number. No prefix nor escape digits included. 1622 */ 1623 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1624 hfp_connection->bnip_type = value; 1625 break; 1626 case 3: 1627 // <speed>: This optional field is not supported, and shall be left blank. 1628 break; 1629 case 4: 1630 // <service>: Indicates which service this phone number relates to. Shall be either 4 (voice) or 5 (fax). 1631 default: 1632 break; 1633 } 1634 // index > 2 are ignored in switch above 1635 hfp_connection->parser_item_index++; 1636 break; 1637 case HFP_CMD_LIST_CURRENT_CALLS: 1638 switch(hfp_connection->parser_item_index){ 1639 case 0: 1640 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1641 hfp_connection->clcc_idx = value; 1642 break; 1643 case 1: 1644 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1645 hfp_connection->clcc_dir = value; 1646 break; 1647 case 2: 1648 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1649 hfp_connection->clcc_status = value; 1650 break; 1651 case 3: 1652 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1653 hfp_connection->clcc_mode = value; 1654 break; 1655 case 4: 1656 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1657 hfp_connection->clcc_mpty = value; 1658 break; 1659 case 5: 1660 btstack_strcpy(hfp_connection->bnip_number, sizeof(hfp_connection->bnip_number), (char *)hfp_connection->line_buffer); 1661 break; 1662 case 6: 1663 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1664 hfp_connection->bnip_type = value; 1665 break; 1666 default: 1667 break; 1668 } 1669 // index > 6 are ignored in switch above 1670 hfp_connection->parser_item_index++; 1671 break; 1672 case HFP_CMD_SET_MICROPHONE_GAIN: 1673 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1674 hfp_connection->microphone_gain = value; 1675 log_info("hfp parse HFP_CMD_SET_MICROPHONE_GAIN %d\n", value); 1676 break; 1677 case HFP_CMD_SET_SPEAKER_GAIN: 1678 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1679 hfp_connection->speaker_gain = value; 1680 log_info("hfp parse HFP_CMD_SET_SPEAKER_GAIN %d\n", value); 1681 break; 1682 case HFP_CMD_TURN_OFF_EC_AND_NR: 1683 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1684 hfp_connection->ag_echo_and_noise_reduction = value; 1685 log_info("hfp parse HFP_CMD_TURN_OFF_EC_AND_NR %d\n", value); 1686 break; 1687 case HFP_CMD_CHANGE_IN_BAND_RING_TONE_SETTING: 1688 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1689 hfp_connection->remote_supported_features = store_bit(hfp_connection->remote_supported_features, HFP_AGSF_IN_BAND_RING_TONE, value); 1690 log_info("hfp parse HFP_CHANGE_IN_BAND_RING_TONE_SETTING %d\n", value); 1691 break; 1692 case HFP_CMD_HF_CONFIRMED_CODEC: 1693 hfp_connection->codec_confirmed = btstack_atoi((char*)hfp_connection->line_buffer); 1694 log_info("hfp parse HFP_CMD_HF_CONFIRMED_CODEC %d\n", hfp_connection->codec_confirmed); 1695 break; 1696 case HFP_CMD_AG_SUGGESTED_CODEC: 1697 hfp_connection->suggested_codec = btstack_atoi((char*)hfp_connection->line_buffer); 1698 log_info("hfp parse HFP_CMD_AG_SUGGESTED_CODEC %d\n", hfp_connection->suggested_codec); 1699 break; 1700 case HFP_CMD_SUPPORTED_FEATURES: 1701 hfp_connection->remote_supported_features = btstack_atoi((char*)hfp_connection->line_buffer); 1702 log_info("Parsed supported feature %d\n", (int) hfp_connection->remote_supported_features); 1703 break; 1704 case HFP_CMD_AVAILABLE_CODECS: 1705 log_info("Parsed codec %s\n", hfp_connection->line_buffer); 1706 hfp_connection->remote_codecs[hfp_connection->parser_item_index] = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1707 hfp_next_codec_index(hfp_connection); 1708 hfp_connection->remote_codecs_nr = hfp_connection->parser_item_index; 1709 break; 1710 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1711 btstack_strcpy((char *)hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, HFP_MAX_INDICATOR_DESC_SIZE, (char *)hfp_connection->line_buffer); 1712 hfp_connection->ag_indicators[hfp_connection->parser_item_index].index = hfp_connection->parser_item_index+1; 1713 log_info("Indicator %d: %s (", hfp_connection->ag_indicators_nr+1, hfp_connection->line_buffer); 1714 break; 1715 case HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS: 1716 log_info("Parsed Indicator %d with status: %s\n", hfp_connection->parser_item_index+1, hfp_connection->line_buffer); 1717 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status = btstack_atoi((char *) hfp_connection->line_buffer); 1718 hfp_next_indicators_index(hfp_connection); 1719 break; 1720 case HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE: 1721 hfp_next_indicators_index(hfp_connection); 1722 if (hfp_connection->parser_item_index != 4) break; 1723 log_info("Parsed Enable indicators: %s\n", hfp_connection->line_buffer); 1724 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1725 hfp_connection->enable_status_update_for_ag_indicators = (uint8_t) value; 1726 break; 1727 case HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES: 1728 log_info("Parsed Support call hold: %s\n", hfp_connection->line_buffer); 1729 if (hfp_connection->line_size > 2 ) break; 1730 memcpy((char *)hfp_connection->remote_call_services[hfp_connection->remote_call_services_index].name, (char *)hfp_connection->line_buffer, HFP_CALL_SERVICE_SIZE-1); 1731 hfp_connection->remote_call_services[hfp_connection->remote_call_services_index].name[HFP_CALL_SERVICE_SIZE - 1] = 0; 1732 hfp_next_remote_call_services_index(hfp_connection); 1733 break; 1734 case HFP_CMD_LIST_GENERIC_STATUS_INDICATORS: 1735 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS: 1736 log_info("Parsed Generic status indicator: %s\n", hfp_connection->line_buffer); 1737 hfp_connection->generic_status_indicators[hfp_connection->parser_item_index].uuid = (uint16_t)btstack_atoi((char*)hfp_connection->line_buffer); 1738 hfp_next_indicators_index(hfp_connection); 1739 hfp_connection->generic_status_indicators_nr = hfp_connection->parser_item_index; 1740 break; 1741 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1742 // HF parses inital AG gen. ind. state 1743 log_info("Parsed List generic status indicator %s state: ", hfp_connection->line_buffer); 1744 hfp_connection->parser_item_index = hfp_parse_indicator_index(hfp_connection); 1745 break; 1746 case HFP_CMD_HF_INDICATOR_STATUS: 1747 hfp_connection->parser_indicator_index = hfp_parse_indicator_index(hfp_connection); 1748 log_info("Parsed HF indicator index %u", hfp_connection->parser_indicator_index); 1749 break; 1750 case HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE: 1751 // AG parses new gen. ind. state 1752 if (hfp_connection->ignore_value){ 1753 hfp_connection->ignore_value = 0; 1754 log_info("Parsed Enable AG indicator pos %u('%s') - unchanged (stays %u)\n", hfp_connection->parser_item_index, 1755 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, hfp_connection->ag_indicators[hfp_connection->parser_item_index].enabled); 1756 } 1757 else if (hfp_connection->ag_indicators[hfp_connection->parser_item_index].mandatory){ 1758 log_info("Parsed Enable AG indicator pos %u('%s') - ignore (mandatory)\n", 1759 hfp_connection->parser_item_index, hfp_connection->ag_indicators[hfp_connection->parser_item_index].name); 1760 } else { 1761 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1762 hfp_connection->ag_indicators[hfp_connection->parser_item_index].enabled = value; 1763 log_info("Parsed Enable AG indicator pos %u('%s'): %u\n", hfp_connection->parser_item_index, 1764 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, value); 1765 } 1766 hfp_next_indicators_index(hfp_connection); 1767 break; 1768 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1769 // indicators are indexed starting with 1 1770 hfp_connection->parser_item_index = hfp_parse_indicator_index(hfp_connection); 1771 log_info("Parsed status of the AG indicator %d, status ", hfp_connection->parser_item_index); 1772 break; 1773 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1774 hfp_connection->network_operator.mode = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1775 log_info("Parsed network operator mode: %d, ", hfp_connection->network_operator.mode); 1776 break; 1777 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1778 if (hfp_connection->line_buffer[0] == '3'){ 1779 log_info("Parsed Set network operator format : %s, ", hfp_connection->line_buffer); 1780 break; 1781 } 1782 // TODO emit ERROR, wrong format 1783 log_info("ERROR Set network operator format: index %s not supported\n", hfp_connection->line_buffer); 1784 break; 1785 case HFP_CMD_ERROR: 1786 break; 1787 case HFP_CMD_EXTENDED_AUDIO_GATEWAY_ERROR: 1788 hfp_connection->extended_audio_gateway_error = 1; 1789 hfp_connection->extended_audio_gateway_error_value = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1790 break; 1791 case HFP_CMD_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR: 1792 hfp_connection->enable_extended_audio_gateway_error_report = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1793 hfp_connection->extended_audio_gateway_error = 0; 1794 break; 1795 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1796 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1797 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1798 btstack_strcpy((char *)hfp_connection->bnip_number, sizeof(hfp_connection->bnip_number), (char *)hfp_connection->line_buffer); 1799 break; 1800 case HFP_CMD_CALL_HOLD: 1801 hfp_connection->ag_call_hold_action = hfp_connection->line_buffer[0] - '0'; 1802 if (hfp_connection->line_buffer[1] != '\0'){ 1803 hfp_connection->call_index = btstack_atoi((char *)&hfp_connection->line_buffer[1]); 1804 } 1805 break; 1806 case HFP_CMD_RESPONSE_AND_HOLD_COMMAND: 1807 hfp_connection->ag_response_and_hold_action = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1808 break; 1809 case HFP_CMD_TRANSMIT_DTMF_CODES: 1810 hfp_connection->ag_dtmf_code = hfp_connection->line_buffer[0]; 1811 break; 1812 case HFP_CMD_ENABLE_CLIP: 1813 hfp_connection->clip_enabled = hfp_connection->line_buffer[0] != '0'; 1814 break; 1815 case HFP_CMD_ENABLE_CALL_WAITING_NOTIFICATION: 1816 hfp_connection->call_waiting_notification_enabled = hfp_connection->line_buffer[0] != '0'; 1817 break; 1818 case HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION: 1819 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1820 hfp_connection->ag_activate_voice_recognition_value = value; 1821 break; 1822 case HFP_CMD_AG_ACTIVATE_VOICE_RECOGNITION: 1823 switch(hfp_connection->parser_item_index){ 1824 case 0: 1825 hfp_connection->ag_vra_status = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1826 break; 1827 case 1: 1828 hfp_connection->ag_vra_state = (hfp_voice_recognition_state_t) btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1829 break; 1830 case 2: 1831 hfp_connection->ag_msg.text_id = 0; 1832 for (i = 0 ; i < 4; i++){ 1833 hfp_connection->ag_msg.text_id = (hfp_connection->ag_msg.text_id << 4) | nibble_for_char(hfp_connection->line_buffer[i]); 1834 } 1835 break; 1836 case 3: 1837 hfp_connection->ag_msg.text_type = (hfp_text_type_t) btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1838 break; 1839 case 4: 1840 hfp_connection->ag_msg.text_operation = (hfp_text_operation_t) btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1841 break; 1842 case 5: 1843 hfp_connection->line_buffer[hfp_connection->line_size] = 0; 1844 hfp_connection->ag_vra_msg_length = hfp_connection->line_size + 1; 1845 break; 1846 default: 1847 break; 1848 } 1849 hfp_connection->parser_item_index++; 1850 break; 1851 default: 1852 break; 1853 } 1854 } 1855 1856 static void hfp_handle_start_sdp_client_query(void * context){ 1857 UNUSED(context); 1858 1859 btstack_linked_list_iterator_t it; 1860 btstack_linked_list_iterator_init(&it, &hfp_connections); 1861 while (btstack_linked_list_iterator_has_next(&it)){ 1862 hfp_connection_t * connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1863 1864 if (connection->state != HFP_W2_SEND_SDP_QUERY) continue; 1865 1866 connection->state = HFP_W4_SDP_QUERY_COMPLETE; 1867 hfp_sdp_query_context.local_role = connection->local_role; 1868 (void)memcpy(hfp_sdp_query_context.remote_address, connection->remote_addr, 6); 1869 sdp_client_query_rfcomm_channel_and_name_for_service_class_uuid(&handle_query_rfcomm_event, connection->remote_addr, connection->service_uuid); 1870 return; 1871 } 1872 } 1873 1874 uint8_t hfp_establish_service_level_connection(bd_addr_t bd_addr, uint16_t service_uuid, hfp_role_t local_role){ 1875 hfp_connection_t * connection = get_hfp_connection_context_for_bd_addr(bd_addr, local_role); 1876 if (connection != NULL){ 1877 // allow to call hfp_establish_service_level_connection after SLC was triggered remotely 1878 // @note this also allows to call hfp_establish_service_level_connection again before SLC is complete 1879 if (connection->state < HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED){ 1880 return ERROR_CODE_SUCCESS; 1881 } else { 1882 return ERROR_CODE_COMMAND_DISALLOWED; 1883 } 1884 } 1885 1886 connection = hfp_create_connection(bd_addr, local_role); 1887 if (!connection){ 1888 return BTSTACK_MEMORY_ALLOC_FAILED; 1889 } 1890 1891 connection->state = HFP_W2_SEND_SDP_QUERY; 1892 1893 bd_addr_copy(connection->remote_addr, bd_addr); 1894 connection->service_uuid = service_uuid; 1895 1896 if (local_role == HFP_ROLE_HF) { 1897 // setup HF Indicators 1898 uint8_t i; 1899 for (i=0; i < hfp_hf_indicators_nr; i++){ 1900 connection->generic_status_indicators[i].uuid = hfp_hf_indicators[i]; 1901 connection->generic_status_indicators[i].state = 0; 1902 } 1903 } 1904 1905 hfp_sdp_query_request.callback = &hfp_handle_start_sdp_client_query; 1906 // ignore ERROR_CODE_COMMAND_DISALLOWED because in that case, we already have requested an SDP callback 1907 (void) sdp_client_register_query_callback(&hfp_sdp_query_request); 1908 return ERROR_CODE_SUCCESS; 1909 } 1910 1911 void hfp_trigger_release_service_level_connection(hfp_connection_t * hfp_connection){ 1912 // called internally, NULL check already performed 1913 btstack_assert(hfp_connection != NULL); 1914 1915 hfp_trigger_release_audio_connection(hfp_connection); 1916 if (hfp_connection->state < HFP_W4_RFCOMM_CONNECTED){ 1917 hfp_connection->state = HFP_IDLE; 1918 return; 1919 } 1920 1921 if (hfp_connection->state == HFP_W4_RFCOMM_CONNECTED){ 1922 hfp_connection->state = HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN; 1923 return; 1924 } 1925 hfp_connection->release_slc_connection = 1; 1926 if (hfp_connection->state < HFP_W4_SCO_CONNECTED){ 1927 hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM; 1928 return; 1929 } 1930 1931 if (hfp_connection->state < HFP_W4_SCO_DISCONNECTED){ 1932 hfp_connection->state = HFP_W2_DISCONNECT_SCO; 1933 hfp_connection->release_audio_connection = 1; 1934 return; 1935 } 1936 } 1937 1938 uint8_t hfp_trigger_release_audio_connection(hfp_connection_t * hfp_connection){ 1939 // called internally, NULL check already performed 1940 btstack_assert(hfp_connection != NULL); 1941 if (hfp_connection->state <= HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED){ 1942 return ERROR_CODE_COMMAND_DISALLOWED; 1943 } 1944 switch (hfp_connection->state) { 1945 case HFP_W2_CONNECT_SCO: 1946 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 1947 break; 1948 case HFP_W4_SCO_CONNECTED: 1949 case HFP_AUDIO_CONNECTION_ESTABLISHED: 1950 hfp_connection->release_audio_connection = 1; 1951 break; 1952 default: 1953 return ERROR_CODE_COMMAND_DISALLOWED; 1954 } 1955 return ERROR_CODE_SUCCESS; 1956 } 1957 1958 bool hfp_sco_setup_active(void){ 1959 return hfp_sco_establishment_active != NULL; 1960 } 1961 1962 void hfp_setup_synchronous_connection(hfp_connection_t * hfp_connection){ 1963 1964 hfp_sco_establishment_active = hfp_connection; 1965 1966 // all packet types, fixed bandwidth 1967 int setting = hfp_connection->link_setting; 1968 log_info("hfp_setup_synchronous_connection using setting nr %u", setting); 1969 uint16_t sco_voice_setting = hci_get_sco_voice_setting(); 1970 if (hfp_connection->negotiated_codec != HFP_CODEC_CVSD){ 1971 #ifdef ENABLE_BCM_PCM_WBS 1972 sco_voice_setting = 0x0063; // Transparent data, 16-bit for BCM controllers 1973 #else 1974 sco_voice_setting = 0x0043; // Transparent data, 8-bit otherwise 1975 #endif 1976 } 1977 uint16_t packet_types = hfp_link_settings[setting].packet_types; 1978 hfp_connection->packet_types = packet_types; 1979 1980 // get packet types - bits 6-9 are 'don't allow' 1981 uint16_t packet_types_flipped = packet_types ^ 0x03c0; 1982 #if defined(ENABLE_SCO_OVER_PCM) && defined(ENABLE_NXP_PCM_WBS) 1983 uint8_t radio_coding_format = 3; 1984 uint32_t host_bandwidth = 0; 1985 uint8_t coded_data_size = 0; 1986 switch (hfp_connection->negotiated_codec){ 1987 case HFP_CODEC_CVSD: 1988 radio_coding_format = 0x02; 1989 host_bandwidth = 16000; 1990 coded_data_size = 0x10; 1991 break; 1992 case HFP_CODEC_MSBC: 1993 radio_coding_format = 0x05; 1994 host_bandwidth = 32000; 1995 coded_data_size = 0x08; 1996 break; 1997 default: 1998 log_error("Coding format %u not supported by Controller", hfp_connection->negotiated_codec); 1999 btstack_assert(false); 2000 break; 2001 } 2002 hci_send_cmd(&hci_enhanced_setup_synchronous_connection, 2003 // ACL Handle 2004 hfp_connection->acl_handle, 2005 // Transmit_Bandwidth 2006 8000, 2007 // Receive_Bandwidth 2008 8000, 2009 // Transmit_Coding_Format: radio_config_format, company, codec 2010 radio_coding_format, 0x00, 0x00, 2011 // Receive_Coding_Format: radio_config_format, company, codec 2012 radio_coding_format, 0x00, 0x00, 2013 // Transmit_Codec_Frame_Size 2014 0x3c, 2015 // Receive_Codec_Frame_Size 2016 0x3c, 2017 // Input_Bandwidth 2018 host_bandwidth, 2019 // Output_Bandwidth 2020 host_bandwidth, 2021 // Input_Coding_Format, 0x04 = Linear PCM, company, codec 2022 0x04, 0x00, 0x00, 2023 // Output_Coding_Format, 0x04 = Linear PCM, company, codec 2024 0x04, 0x00, 0x00, 2025 // Input_Coded_Data_Size 2026 coded_data_size, 2027 // Output_Coded_Data_Size 2028 coded_data_size, 2029 // Input_PCM_Data_Format, 0x02 = 2’s complement 2030 0x02, 2031 // Output_PCM_Data_Format, 0x02 = 2’s complement 2032 0x02, 2033 // Input_PCM_Sample_Payload_MSB_Position 2034 0x00, 2035 // Output_PCM_Sample_Payload_MSB_Position 2036 0x00, 2037 // Input_Data_Path - vendor specific: NXP - I2S/PCM 2038 0x01, 2039 // Output_Data_Path - vendor specific: NXP - I2S/PCM 2040 0x01, 2041 // Input_Transport_Unit_Size 2042 0x10, 2043 // Output_Transport_Unit_Size 2044 0x10, 2045 // 2046 hfp_link_settings[setting].max_latency, 2047 packet_types_flipped, 2048 hfp_link_settings[setting].retransmission_effort); 2049 #else 2050 hci_send_cmd(&hci_setup_synchronous_connection, hfp_connection->acl_handle, 8000, 8000, hfp_link_settings[setting].max_latency, 2051 sco_voice_setting, hfp_link_settings[setting].retransmission_effort, packet_types_flipped); 2052 #endif 2053 } 2054 2055 #ifdef ENABLE_HFP_HF_SAFE_SETTINGS 2056 hfp_link_settings_t hfp_safe_settings_for_context(bool use_eSCO, uint8_t negotiated_codec, bool secure_connection_in_use){ 2057 uint8_t i; 2058 hfp_link_settings_t link_setting = HFP_LINK_SETTINGS_NONE; 2059 for (i=0 ; i < (sizeof(hfp_mandatory_safe_settings) / sizeof(struct hfp_mandatory_safe_setting)) ; i++){ 2060 uint16_t packet_types = hfp_link_settings[(uint8_t)(hfp_mandatory_safe_settings[i].link_setting)].packet_types; 2061 bool is_eSCO_setting = (packet_types & SCO_PACKET_TYPES_ESCO) != 0; 2062 if (is_eSCO_setting != use_eSCO) continue; 2063 if ((hfp_mandatory_safe_settings[i].codec_mask & (1 << negotiated_codec)) == 0) continue; 2064 if (hfp_mandatory_safe_settings[i].secure_connection_in_use != secure_connection_in_use) continue; 2065 link_setting = hfp_mandatory_safe_settings[i].link_setting; 2066 break; 2067 } 2068 return link_setting; 2069 } 2070 #endif 2071 2072 void hfp_accept_synchronous_connection(hfp_connection_t * hfp_connection, bool use_eSCO){ 2073 2074 hfp_sco_establishment_active = hfp_connection; 2075 2076 // lookup safe settings based on SCO type, SC use and Codec type 2077 uint16_t max_latency; 2078 uint16_t packet_types; 2079 uint16_t retransmission_effort; 2080 2081 #ifdef ENABLE_HFP_HF_SAFE_SETTINGS 2082 hfp_link_settings_t link_setting = HFP_LINK_SETTINGS_NONE; 2083 // fallback for non-CVSD codec and SCO connection 2084 if ((hfp_connection->negotiated_codec != HFP_CODEC_CVSD) && (use_eSCO == false)){ 2085 max_latency = 0xffff; 2086 retransmission_effort = 0xff; 2087 packet_types = SCO_PACKET_TYPES_HV3 | SCO_PACKET_TYPES_HV1; 2088 } else { 2089 // use safe settings from HFP v1.9, table 6.10 2090 bool secure_connection_in_use = gap_secure_connection(hfp_connection->acl_handle); 2091 link_setting = hfp_safe_settings_for_context(use_eSCO, hfp_connection->negotiated_codec, secure_connection_in_use); 2092 max_latency = hfp_link_settings[(uint8_t) link_setting].max_latency; 2093 retransmission_effort = hfp_link_settings[(uint8_t) link_setting].retransmission_effort; 2094 packet_types = hfp_link_settings[(uint8_t) link_setting].packet_types; 2095 } 2096 #else 2097 max_latency = 0xffff; 2098 retransmission_effort = 0xff; 2099 if (use_eSCO) { 2100 packet_types = SCO_PACKET_TYPES_EV3 | SCO_PACKET_TYPES_2EV3; 2101 } else { 2102 packet_types = SCO_PACKET_TYPES_HV3 | SCO_PACKET_TYPES_HV1; 2103 } 2104 #endif 2105 2106 // transparent data for non-CVSD connections or if codec provided by Controller 2107 uint16_t sco_voice_setting = hci_get_sco_voice_setting(); 2108 if (hfp_connection->negotiated_codec != HFP_CODEC_CVSD){ 2109 #ifdef ENABLE_BCM_PCM_WBS 2110 sco_voice_setting = 0x0063; // Transparent data, 16-bit for BCM controllers 2111 #else 2112 sco_voice_setting = 0x0043; // Transparent data, 8-bit otherwise 2113 #endif 2114 } 2115 2116 // filter packet types 2117 packet_types &= hfp_get_sco_packet_types(); 2118 2119 hfp_connection->packet_types = packet_types; 2120 2121 // bits 6-9 are 'don't allow' 2122 uint16_t packet_types_flipped = packet_types ^ 0x3c0; 2123 2124 log_info("Sending hci_accept_connection_request: packet types 0x%04x, sco_voice_setting 0x%02x", 2125 packet_types, sco_voice_setting); 2126 2127 #if defined(ENABLE_SCO_OVER_PCM) && defined(ENABLE_NXP_PCM_WBS) 2128 uint8_t radio_coding_format = 3; 2129 uint32_t host_bandwidth = 0; 2130 uint8_t coded_data_size = 0; 2131 switch (hfp_connection->negotiated_codec){ 2132 case HFP_CODEC_CVSD: 2133 radio_coding_format = 0x02; 2134 host_bandwidth = 16000; 2135 coded_data_size = 0x10; 2136 break; 2137 case HFP_CODEC_MSBC: 2138 radio_coding_format = 0x05; 2139 host_bandwidth = 32000; 2140 coded_data_size = 0x08; 2141 break; 2142 default: 2143 log_error("Coding format %u not supported by Controller", hfp_connection->negotiated_codec); 2144 btstack_assert(false); 2145 break; 2146 } 2147 hci_send_cmd(&hci_enhanced_accept_synchronous_connection, 2148 // BD_ADDR 2149 hfp_connection->remote_addr, 2150 // Transmit_Bandwidth 2151 8000, 2152 // Receive_Bandwidth 2153 8000, 2154 // Transmit_Coding_Format: radio_config_format, company, codec 2155 radio_coding_format, 0x00, 0x00, 2156 // Receive_Coding_Format: radio_config_format, company, codec 2157 radio_coding_format, 0x00, 0x00, 2158 // Transmit_Codec_Frame_Size 2159 0x3c, 2160 // Receive_Codec_Frame_Size 2161 0x3c, 2162 // Input_Bandwidth 2163 host_bandwidth, 2164 // Output_Bandwidth 2165 host_bandwidth, 2166 // Input_Coding_Format, 0x04 = Linear PCM, company, codec 2167 0x04, 0x00, 0x00, 2168 // Output_Coding_Format, 0x04 = Linear PCM, company, codec 2169 0x04, 0x00, 0x00, 2170 // Input_Coded_Data_Size 2171 coded_data_size, 2172 // Output_Coded_Data_Size 2173 coded_data_size, 2174 // Input_PCM_Data_Format, 0x02 = 2’s complement 2175 0x02, 2176 // Output_PCM_Data_Format, 0x02 = 2’s complement 2177 0x02, 2178 // Input_PCM_Sample_Payload_MSB_Position 2179 0x00, 2180 // Output_PCM_Sample_Payload_MSB_Position 2181 0x00, 2182 // Input_Data_Path - vendor specific: NXP - I2S/PCM 2183 0x01, 2184 // Output_Data_Path - vendor specific: NXP - I2S/PCM 2185 0x01, 2186 // Input_Transport_Unit_Size 2187 0x10, 2188 // Output_Transport_Unit_Size 2189 0x10, 2190 // 2191 max_latency, 2192 packet_types_flipped, 2193 retransmission_effort); 2194 #else 2195 hci_send_cmd(&hci_accept_synchronous_connection, hfp_connection->remote_addr, 8000, 8000, max_latency, 2196 sco_voice_setting, retransmission_effort, packet_types_flipped); 2197 #endif 2198 } 2199 2200 #ifdef ENABLE_CC256X_ASSISTED_HFP 2201 void hfp_cc256x_write_codec_config(hfp_connection_t * hfp_connection){ 2202 uint32_t sample_rate_hz; 2203 uint16_t clock_rate_khz; 2204 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 2205 clock_rate_khz = 512; 2206 sample_rate_hz = 16000; 2207 } else { 2208 clock_rate_khz = 256; 2209 sample_rate_hz = 8000; 2210 } 2211 uint8_t clock_direction = 0; // master 2212 uint16_t frame_sync_duty_cycle = 0; // i2s with 50% 2213 uint8_t frame_sync_edge = 1; // rising edge 2214 uint8_t frame_sync_polarity = 0; // active high 2215 uint8_t reserved = 0; 2216 uint16_t size = 16; 2217 uint16_t chan_1_offset = 1; 2218 uint16_t chan_2_offset = chan_1_offset + size; 2219 uint8_t out_edge = 1; // rising 2220 uint8_t in_edge = 0; // falling 2221 hci_send_cmd(&hci_ti_write_codec_config, clock_rate_khz, clock_direction, sample_rate_hz, frame_sync_duty_cycle, 2222 frame_sync_edge, frame_sync_polarity, reserved, 2223 size, chan_1_offset, out_edge, size, chan_1_offset, in_edge, reserved, 2224 size, chan_2_offset, out_edge, size, chan_2_offset, in_edge, reserved); 2225 } 2226 #endif 2227 2228 #ifdef ENABLE_BCM_PCM_WBS 2229 void hfp_bcm_write_i2spcm_interface_param(hfp_connection_t * hfp_connection){ 2230 uint8_t sample_rate = (hfp_connection->negotiated_codec == HFP_CODEC_MSBC) ? 1 : 0; 2231 // i2s enable, master, 8/16 kHz, 512 kHz 2232 hci_send_cmd(&hci_bcm_write_i2spcm_interface_param, 1, 1, sample_rate, 2); 2233 } 2234 #endif 2235 2236 void hfp_prepare_for_sco(hfp_connection_t * hfp_connection){ 2237 UNUSED(hfp_connection); 2238 #ifdef ENABLE_CC256X_ASSISTED_HFP 2239 hfp_connection->cc256x_send_write_codec_config = true; 2240 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 2241 hfp_connection->cc256x_send_wbs_associate = true; 2242 } 2243 #endif 2244 2245 #ifdef ENABLE_BCM_PCM_WBS 2246 #ifndef HAVE_BCM_PCM_NBS_16KHZ 2247 hfp_connection->bcm_send_write_i2spcm_interface_param = true; 2248 #endif 2249 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 2250 hfp_connection->bcm_send_enable_wbs = true; 2251 } 2252 #endif 2253 2254 #ifdef ENABLE_RTK_PCM_WBS 2255 hfp_connection->rtk_send_sco_config = true; 2256 #endif 2257 } 2258 2259 void hfp_set_hf_callback(btstack_packet_handler_t callback){ 2260 hfp_hf_callback = callback; 2261 } 2262 2263 void hfp_set_ag_callback(btstack_packet_handler_t callback){ 2264 hfp_ag_callback = callback; 2265 } 2266 2267 void hfp_set_ag_rfcomm_packet_handler(btstack_packet_handler_t handler){ 2268 hfp_ag_rfcomm_packet_handler = handler; 2269 } 2270 2271 void hfp_set_hf_rfcomm_packet_handler(btstack_packet_handler_t handler){ 2272 hfp_hf_rfcomm_packet_handler = handler; 2273 } 2274 2275 void hfp_set_hf_indicators(uint8_t indicators_nr, const uint8_t * indicators) { 2276 hfp_hf_indicators_nr = indicators_nr; 2277 hfp_hf_indicators = indicators; 2278 } 2279 2280 void hfp_init(void){ 2281 hfp_allowed_sco_packet_types = SCO_PACKET_TYPES_ALL; 2282 } 2283 2284 void hfp_deinit(void){ 2285 hfp_allowed_sco_packet_types = 0; 2286 hfp_connections = NULL; 2287 hfp_hf_callback = NULL; 2288 hfp_ag_callback = NULL; 2289 hfp_hf_rfcomm_packet_handler = NULL; 2290 hfp_ag_rfcomm_packet_handler = NULL; 2291 hfp_sco_establishment_active = NULL; 2292 hfp_custom_commands_ag = NULL; 2293 hfp_custom_commands_hf = NULL; 2294 (void) memset(&hfp_sdp_query_context, 0, sizeof(hfp_sdp_query_context_t)); 2295 (void) memset(&hfp_sdp_query_request, 0, sizeof(btstack_context_callback_registration_t)); 2296 } 2297 2298 void hfp_set_sco_packet_types(uint16_t packet_types){ 2299 hfp_allowed_sco_packet_types = packet_types; 2300 } 2301 2302 uint16_t hfp_get_sco_packet_types(void){ 2303 return hfp_allowed_sco_packet_types; 2304 } 2305 2306 hfp_link_settings_t hfp_next_link_setting(hfp_link_settings_t current_setting, uint16_t local_sco_packet_types, 2307 uint16_t remote_sco_packet_types, bool eSCO_S4_supported, 2308 uint8_t negotiated_codec) { 2309 int8_t setting = (int8_t) current_setting; 2310 while (setting > 0){ 2311 setting--; 2312 // skip S4 if not supported 2313 if ((setting == (int8_t) HFP_LINK_SETTINGS_S4) && !eSCO_S4_supported) continue; 2314 // skip wrong codec 2315 if ((hfp_link_settings[setting].codec_mask & (1 << negotiated_codec)) == 0) continue; 2316 // skip disabled or not supported packet types 2317 uint16_t required_packet_types = hfp_link_settings[setting].packet_types; 2318 uint16_t allowed_packet_types = hfp_allowed_sco_packet_types & local_sco_packet_types & remote_sco_packet_types; 2319 if ((required_packet_types & allowed_packet_types) == 0) continue; 2320 2321 // found matching setting 2322 return (hfp_link_settings_t) setting; 2323 } 2324 return HFP_LINK_SETTINGS_NONE; 2325 } 2326 2327 static hfp_link_settings_t hfp_next_link_setting_for_connection(hfp_link_settings_t current_setting, hfp_connection_t * hfp_connection, uint8_t eSCO_S4_supported){ 2328 uint8_t negotiated_codec = hfp_connection->negotiated_codec; 2329 uint16_t local_sco_packet_types = hci_usable_sco_packet_types(); 2330 uint16_t remote_sco_packet_types = hci_remote_sco_packet_types(hfp_connection->acl_handle); 2331 return hfp_next_link_setting(current_setting, local_sco_packet_types, remote_sco_packet_types, eSCO_S4_supported, 2332 negotiated_codec); 2333 } 2334 2335 void hfp_init_link_settings(hfp_connection_t * hfp_connection, uint8_t eSCO_S4_supported){ 2336 // get highest possible link setting 2337 hfp_connection->link_setting = hfp_next_link_setting_for_connection(HFP_LINK_SETTINGS_NONE, hfp_connection, eSCO_S4_supported); 2338 log_info("hfp_init_link_settings: %u", hfp_connection->link_setting); 2339 } 2340 2341 #define HFP_HF_RX_DEBUG_PRINT_LINE 80 2342 2343 void hfp_log_rfcomm_message(const char * tag, uint8_t * packet, uint16_t size){ 2344 #ifdef ENABLE_LOG_INFO 2345 // encode \n\r 2346 char printable[HFP_HF_RX_DEBUG_PRINT_LINE+2]; 2347 int i = 0; 2348 int pos; 2349 for (pos=0 ; (pos < size) && (i < (HFP_HF_RX_DEBUG_PRINT_LINE - 3)) ; pos++){ 2350 switch (packet[pos]){ 2351 case '\n': 2352 printable[i++] = '\\'; 2353 printable[i++] = 'n'; 2354 break; 2355 case '\r': 2356 printable[i++] = '\\'; 2357 printable[i++] = 'r'; 2358 break; 2359 default: 2360 printable[i++] = packet[pos]; 2361 break; 2362 } 2363 } 2364 printable[i] = 0; 2365 log_info("%s: '%s'", tag, printable); 2366 #endif 2367 } 2368 2369 void hfp_register_custom_ag_command(hfp_custom_at_command_t * custom_at_command){ 2370 btstack_linked_list_add(&hfp_custom_commands_ag, (btstack_linked_item_t *) custom_at_command); 2371 } 2372 2373 void hfp_register_custom_hf_command(hfp_custom_at_command_t * custom_at_command){ 2374 btstack_linked_list_add(&hfp_custom_commands_hf, (btstack_linked_item_t *) custom_at_command); 2375 } 2376 2377 // HFP H2 Synchronization - might get moved into a hfp_h2.c 2378 2379 // find position of h2 sync header, returns -1 if not found, or h2 sync position 2380 static int16_t hfp_h2_sync_find(const uint8_t * frame_data, uint16_t frame_len){ 2381 uint16_t i; 2382 for (i=0;i<(frame_len - 1);i++){ 2383 // check: first byte == 1 2384 uint8_t h2_first_byte = frame_data[i]; 2385 if (h2_first_byte == 0x01) { 2386 uint8_t h2_second_byte = frame_data[i + 1]; 2387 // check lower nibble of second byte == 0x08 2388 if ((h2_second_byte & 0x0F) == 8) { 2389 // check if bits 0+2 == bits 1+3 2390 uint8_t hn = h2_second_byte >> 4; 2391 if (((hn >> 1) & 0x05) == (hn & 0x05)) { 2392 return (int16_t) i; 2393 } 2394 } 2395 } 2396 } 2397 return -1; 2398 } 2399 2400 static void hfp_h2_sync_reset(hfp_h2_sync_t * hfp_h2_sync){ 2401 hfp_h2_sync->frame_len = 0; 2402 } 2403 2404 void hfp_h2_sync_init(hfp_h2_sync_t * hfp_h2_sync, 2405 bool (*callback)(bool bad_frame, const uint8_t * frame_data, uint16_t frame_len)){ 2406 hfp_h2_sync->callback = callback; 2407 hfp_h2_sync->dropped_bytes = 0; 2408 hfp_h2_sync_reset(hfp_h2_sync); 2409 } 2410 2411 static void hfp_h2_report_bad_frames(hfp_h2_sync_t *hfp_h2_sync){ 2412 // report bad frames 2413 while (hfp_h2_sync->dropped_bytes >= HFP_H2_SYNC_FRAME_SIZE){ 2414 hfp_h2_sync->dropped_bytes -= HFP_H2_SYNC_FRAME_SIZE; 2415 (void)(*hfp_h2_sync->callback)(true,NULL, HFP_H2_SYNC_FRAME_SIZE); 2416 } 2417 } 2418 2419 static void hfp_h2_sync_drop_bytes(hfp_h2_sync_t * hfp_h2_sync, uint16_t bytes_to_drop){ 2420 btstack_assert(bytes_to_drop <= hfp_h2_sync->frame_len); 2421 memmove(hfp_h2_sync->frame_data, &hfp_h2_sync->frame_data[bytes_to_drop], hfp_h2_sync->frame_len - bytes_to_drop); 2422 hfp_h2_sync->dropped_bytes += bytes_to_drop; 2423 hfp_h2_sync->frame_len -= bytes_to_drop; 2424 hfp_h2_report_bad_frames(hfp_h2_sync); 2425 } 2426 2427 void hfp_h2_sync_process(hfp_h2_sync_t *hfp_h2_sync, bool bad_frame, const uint8_t *frame_data, uint16_t frame_len) { 2428 2429 if (bad_frame){ 2430 // drop all data 2431 hfp_h2_sync->dropped_bytes += hfp_h2_sync->frame_len; 2432 hfp_h2_sync->frame_len = 0; 2433 // all new data is bad, too 2434 hfp_h2_sync->dropped_bytes += frame_len; 2435 // report frames 2436 hfp_h2_report_bad_frames(hfp_h2_sync); 2437 return; 2438 } 2439 2440 while (frame_len > 0){ 2441 // Fill hfp_h2_sync->frame_buffer 2442 uint16_t bytes_free_in_frame_buffer = HFP_H2_SYNC_FRAME_SIZE - hfp_h2_sync->frame_len; 2443 uint16_t bytes_to_append = btstack_min(frame_len, bytes_free_in_frame_buffer); 2444 memcpy(&hfp_h2_sync->frame_data[hfp_h2_sync->frame_len], frame_data, bytes_to_append); 2445 frame_data += bytes_to_append; 2446 frame_len -= bytes_to_append; 2447 hfp_h2_sync->frame_len += bytes_to_append; 2448 // check complete frame for h2 sync 2449 if (hfp_h2_sync->frame_len == HFP_H2_SYNC_FRAME_SIZE){ 2450 bool valid_frame = true; 2451 int16_t h2_pos = hfp_h2_sync_find(hfp_h2_sync->frame_data, hfp_h2_sync->frame_len); 2452 if (h2_pos < 0){ 2453 // no h2 sync, no valid frame, keep last byte if it is 0x01 2454 if (hfp_h2_sync->frame_data[HFP_H2_SYNC_FRAME_SIZE-1] == 0x01){ 2455 hfp_h2_sync_drop_bytes(hfp_h2_sync, HFP_H2_SYNC_FRAME_SIZE - 1); 2456 } else { 2457 hfp_h2_sync_drop_bytes(hfp_h2_sync, HFP_H2_SYNC_FRAME_SIZE); 2458 } 2459 valid_frame = false; 2460 } 2461 else if (h2_pos > 0){ 2462 // drop data before h2 sync 2463 hfp_h2_sync_drop_bytes(hfp_h2_sync, h2_pos); 2464 valid_frame = false; 2465 } 2466 if (valid_frame) { 2467 // h2 sync at pos 0 and complete frame 2468 bool codec_ok = (*hfp_h2_sync->callback)(false, hfp_h2_sync->frame_data, hfp_h2_sync->frame_len); 2469 if (codec_ok){ 2470 hfp_h2_sync_reset(hfp_h2_sync); 2471 } else { 2472 // drop first two bytes 2473 hfp_h2_sync_drop_bytes(hfp_h2_sync, 2); 2474 } 2475 } 2476 } 2477 } 2478 } 2479