1 /* 2 * Copyright (C) 2014 BlueKitchen GmbH 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the copyright holders nor the names of 14 * contributors may be used to endorse or promote products derived 15 * from this software without specific prior written permission. 16 * 4. Any redistribution, use, or modification is done solely for 17 * personal benefit and not for any commercial purpose or for 18 * monetary gain. 19 * 20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS 24 * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * Please inquire about commercial licensing options at 34 * [email protected] 35 * 36 */ 37 38 #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 uint16_t hfp_allowed_sco_packet_types; 88 static hfp_connection_t * hfp_sco_establishment_active; 89 90 static hfp_sdp_query_context_t hfp_sdp_query_context; 91 static btstack_context_callback_registration_t hfp_sdp_query_request; 92 93 94 95 96 97 98 // prototypes 99 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); 100 static void parse_sequence(hfp_connection_t * context); 101 102 static const char * hfp_hf_features[] = { 103 "EC and/or NR function", 104 "Three-way calling", 105 "CLI presentation capability", 106 "Voice recognition activation", 107 "Remote volume control", 108 109 "Enhanced call status", 110 "Enhanced call control", 111 112 "Codec negotiation", 113 114 "HF Indicators", 115 "eSCO S4 (and T2) Settings Supported", 116 "Reserved for future definition" 117 }; 118 119 static const char * hfp_ag_features[] = { 120 "Three-way calling", 121 "EC and/or NR function", 122 "Voice recognition function", 123 "In-band ring tone capability", 124 "Attach a number to a voice tag", 125 "Ability to reject a call", 126 "Enhanced call status", 127 "Enhanced call control", 128 "Extended Error Result Codes", 129 "Codec negotiation", 130 "HF Indicators", 131 "eSCO S4 (and T2) Settings Supported", 132 "Reserved for future definition" 133 }; 134 135 static const char * hfp_enhanced_call_dir[] = { 136 "outgoing", 137 "incoming" 138 }; 139 140 static const char * hfp_enhanced_call_status[] = { 141 "active", 142 "held", 143 "outgoing dialing", 144 "outgoing alerting", 145 "incoming", 146 "incoming waiting", 147 "call held by response and hold" 148 }; 149 150 static const char * hfp_enhanced_call_mode[] = { 151 "voice", 152 "data", 153 "fax" 154 }; 155 156 static const char * hfp_enhanced_call_mpty[] = { 157 "not a conference call", 158 "conference call" 159 }; 160 161 const char * hfp_enhanced_call_dir2str(uint16_t index){ 162 if (index <= HFP_ENHANCED_CALL_DIR_INCOMING) return hfp_enhanced_call_dir[index]; 163 return "not defined"; 164 } 165 166 const char * hfp_enhanced_call_status2str(uint16_t index){ 167 if (index <= HFP_ENHANCED_CALL_STATUS_CALL_HELD_BY_RESPONSE_AND_HOLD) return hfp_enhanced_call_status[index]; 168 return "not defined"; 169 } 170 171 const char * hfp_enhanced_call_mode2str(uint16_t index){ 172 if (index <= HFP_ENHANCED_CALL_MODE_FAX) return hfp_enhanced_call_mode[index]; 173 return "not defined"; 174 } 175 176 const char * hfp_enhanced_call_mpty2str(uint16_t index){ 177 if (index <= HFP_ENHANCED_CALL_MPTY_CONFERENCE_CALL) return hfp_enhanced_call_mpty[index]; 178 return "not defined"; 179 } 180 181 static uint16_t hfp_parse_indicator_index(hfp_connection_t * hfp_connection){ 182 uint16_t index = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 183 184 if (index > HFP_MAX_NUM_INDICATORS){ 185 log_info("ignoring invalid indicator index bigger then HFP_MAX_NUM_INDICATORS"); 186 return HFP_MAX_NUM_INDICATORS - 1; 187 } 188 189 // indicator index enumeration starts with 1, we substract 1 to store in array with starting index 0 190 if (index > 0){ 191 index -= 1; 192 } else { 193 log_info("ignoring invalid indicator index 0"); 194 return 0; 195 } 196 return index; 197 } 198 199 static void hfp_next_indicators_index(hfp_connection_t * hfp_connection){ 200 if (hfp_connection->parser_item_index < HFP_MAX_NUM_INDICATORS - 1){ 201 hfp_connection->parser_item_index++; 202 } else { 203 log_info("Ignoring additional indicator"); 204 } 205 } 206 207 static void hfp_next_codec_index(hfp_connection_t * hfp_connection){ 208 if (hfp_connection->parser_item_index < HFP_MAX_NUM_CODECS - 1){ 209 hfp_connection->parser_item_index++; 210 } else { 211 log_info("Ignoring additional codec index"); 212 } 213 } 214 215 static void hfp_next_remote_call_services_index(hfp_connection_t * hfp_connection){ 216 if (hfp_connection->remote_call_services_index < HFP_MAX_NUM_CALL_SERVICES - 1){ 217 hfp_connection->remote_call_services_index++; 218 } else { 219 log_info("Ignoring additional remote_call_services"); 220 } 221 } 222 223 const char * hfp_hf_feature(int index){ 224 if (index > HFP_HF_FEATURES_SIZE){ 225 return hfp_hf_features[HFP_HF_FEATURES_SIZE]; 226 } 227 return hfp_hf_features[index]; 228 } 229 230 const char * hfp_ag_feature(int index){ 231 if (index > HFP_AG_FEATURES_SIZE){ 232 return hfp_ag_features[HFP_AG_FEATURES_SIZE]; 233 } 234 return hfp_ag_features[index]; 235 } 236 237 int send_str_over_rfcomm(uint16_t cid, char * command){ 238 if (!rfcomm_can_send_packet_now(cid)) return 1; 239 log_info("HFP_TX %s", command); 240 int err = rfcomm_send(cid, (uint8_t*) command, strlen(command)); 241 if (err){ 242 log_error("rfcomm_send -> error 0x%02x \n", err); 243 } 244 #ifdef ENABLE_HFP_AT_MESSAGES 245 hfp_connection_t * hfp_connection = get_hfp_connection_context_for_rfcomm_cid(cid); 246 hfp_emit_string_event(hfp_connection, HFP_SUBEVENT_AT_MESSAGE_SENT, command); 247 #endif 248 return 1; 249 } 250 251 int hfp_supports_codec(uint8_t codec, int codecs_nr, uint8_t * codecs){ 252 253 // mSBC requires support for eSCO connections 254 if ((codec == HFP_CODEC_MSBC) && !hci_extended_sco_link_supported()) return 0; 255 256 int i; 257 for (i = 0; i < codecs_nr; i++){ 258 if (codecs[i] != codec) continue; 259 return 1; 260 } 261 return 0; 262 } 263 264 void hfp_hf_drop_mSBC_if_eSCO_not_supported(uint8_t * codecs, uint8_t * codecs_nr){ 265 if (hci_extended_sco_link_supported()) return; 266 uint8_t tmp_codecs[HFP_MAX_NUM_CODECS]; 267 int i; 268 int tmp_codec_nr = 0; 269 for (i=0; i < *codecs_nr; i++){ 270 if (codecs[i] == HFP_CODEC_MSBC) continue; 271 tmp_codecs[tmp_codec_nr++] = codecs[i]; 272 } 273 *codecs_nr = tmp_codec_nr; 274 (void)memcpy(codecs, tmp_codecs, tmp_codec_nr); 275 } 276 277 // UTILS 278 int get_bit(uint16_t bitmap, int position){ 279 return (bitmap >> position) & 1; 280 } 281 282 int store_bit(uint32_t bitmap, int position, uint8_t value){ 283 if (value){ 284 bitmap |= 1 << position; 285 } else { 286 bitmap &= ~ (1 << position); 287 } 288 return bitmap; 289 } 290 291 int join(char * buffer, int buffer_size, uint8_t * values, int values_nr){ 292 if (buffer_size < (values_nr * 3)) return 0; 293 int i; 294 int offset = 0; 295 for (i = 0; i < (values_nr-1); i++) { 296 offset += snprintf(buffer+offset, buffer_size-offset, "%d,", values[i]); // puts string into buffer 297 } 298 if (i<values_nr){ 299 offset += snprintf(buffer+offset, buffer_size-offset, "%d", values[i]); 300 } 301 return offset; 302 } 303 304 int join_bitmap(char * buffer, int buffer_size, uint32_t values, int values_nr){ 305 if (buffer_size < (values_nr * 3)) return 0; 306 307 int i; 308 int offset = 0; 309 for (i = 0; i < (values_nr-1); i++) { 310 offset += snprintf(buffer+offset, buffer_size-offset, "%d,", get_bit(values,i)); // puts string into buffer 311 } 312 313 if (i<values_nr){ 314 offset += snprintf(buffer+offset, buffer_size-offset, "%d", get_bit(values,i)); 315 } 316 return offset; 317 } 318 319 static void hfp_emit_event_for_context(hfp_connection_t * hfp_connection, uint8_t * packet, uint16_t size){ 320 if (!hfp_connection) return; 321 btstack_packet_handler_t callback = NULL; 322 switch (hfp_connection->local_role){ 323 case HFP_ROLE_HF: 324 callback = hfp_hf_callback; 325 break; 326 case HFP_ROLE_AG: 327 callback = hfp_ag_callback; 328 break; 329 default: 330 return; 331 } 332 (*callback)(HCI_EVENT_PACKET, 0, packet, size); 333 } 334 335 void hfp_emit_simple_event(hfp_connection_t * hfp_connection, uint8_t event_subtype){ 336 hci_con_handle_t acl_handle = (hfp_connection != NULL) ? hfp_connection->acl_handle : HCI_CON_HANDLE_INVALID; 337 uint8_t event[5]; 338 event[0] = HCI_EVENT_HFP_META; 339 event[1] = sizeof(event) - 2; 340 event[2] = event_subtype; 341 little_endian_store_16(event, 3, acl_handle); 342 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 343 } 344 345 void hfp_emit_event(hfp_connection_t * hfp_connection, uint8_t event_subtype, uint8_t value){ 346 hci_con_handle_t acl_handle = (hfp_connection != NULL) ? hfp_connection->acl_handle : HCI_CON_HANDLE_INVALID; 347 uint8_t event[6]; 348 event[0] = HCI_EVENT_HFP_META; 349 event[1] = sizeof(event) - 2; 350 event[2] = event_subtype; 351 little_endian_store_16(event, 3, acl_handle); 352 event[5] = value; // status 0 == OK 353 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 354 } 355 356 void hfp_emit_voice_recognition_state_event(hfp_connection_t * hfp_connection, uint8_t status){ 357 hci_con_handle_t acl_handle = (hfp_connection != NULL) ? hfp_connection->acl_handle : HCI_CON_HANDLE_INVALID; 358 uint8_t event[7]; 359 event[0] = HCI_EVENT_HFP_META; 360 event[1] = sizeof(event) - 2; 361 event[2] = HFP_SUBEVENT_VOICE_RECOGNITION_STATUS; 362 363 little_endian_store_16(event, 3, acl_handle); 364 event[5] = status; // 0:success 365 366 switch (hfp_connection->vra_state){ 367 case HFP_VRA_VOICE_RECOGNITION_ACTIVATED: 368 event[6] = 1; 369 break; 370 case HFP_VRA_ENHANCED_VOICE_RECOGNITION_READY_FOR_AUDIO: 371 event[6] = 2; 372 break; 373 default: 374 event[6] = 0; 375 break; 376 } 377 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 378 } 379 380 void hfp_emit_enhanced_voice_recognition_hf_ready_for_audio_event(hfp_connection_t * hfp_connection, uint8_t status){ 381 hci_con_handle_t acl_handle = (hfp_connection != NULL) ? hfp_connection->acl_handle : HCI_CON_HANDLE_INVALID; 382 383 uint8_t event[6]; 384 event[0] = HCI_EVENT_HFP_META; 385 event[1] = sizeof(event) - 2; 386 event[2] = HFP_SUBEVENT_ENHANCED_VOICE_RECOGNITION_HF_READY_FOR_AUDIO; 387 little_endian_store_16(event, 3, acl_handle); 388 event[5] = status; 389 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 390 } 391 392 void hfp_emit_enhanced_voice_recognition_state_event(hfp_connection_t * hfp_connection, uint8_t status){ 393 hci_con_handle_t acl_handle = (hfp_connection != NULL) ? hfp_connection->acl_handle : HCI_CON_HANDLE_INVALID; 394 395 uint8_t event[6]; 396 event[0] = HCI_EVENT_HFP_META; 397 event[1] = sizeof(event) - 2; 398 switch (hfp_connection->ag_vra_state){ 399 case HFP_VOICE_RECOGNITION_STATE_AG_READY_TO_ACCEPT_AUDIO_INPUT: 400 event[2] = HFP_SUBEVENT_ENHANCED_VOICE_RECOGNITION_AG_READY_TO_ACCEPT_AUDIO_INPUT; 401 break; 402 case HFP_VOICE_RECOGNITION_STATE_AG_IS_STARTING_SOUND: 403 event[2] = HFP_SUBEVENT_ENHANCED_VOICE_RECOGNITION_AG_IS_STARTING_SOUND; 404 break; 405 case HFP_VOICE_RECOGNITION_STATE_AG_IS_PROCESSING_AUDIO_INPUT: 406 event[2] = HFP_SUBEVENT_ENHANCED_VOICE_RECOGNITION_AG_IS_PROCESSING_AUDIO_INPUT; 407 break; 408 default: 409 btstack_unreachable(); 410 break; 411 } 412 413 little_endian_store_16(event, 3, acl_handle); 414 event[5] = status; 415 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 416 } 417 418 void hfp_emit_slc_connection_event(hfp_connection_t * hfp_connection, uint8_t status, hci_con_handle_t con_handle, bd_addr_t addr){ 419 btstack_assert(hfp_connection != NULL); 420 uint8_t event[12]; 421 int pos = 0; 422 event[pos++] = HCI_EVENT_HFP_META; 423 event[pos++] = sizeof(event) - 2; 424 event[pos++] = HFP_SUBEVENT_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 425 little_endian_store_16(event, pos, con_handle); 426 pos += 2; 427 event[pos++] = status; // status 0 == OK 428 reverse_bd_addr(addr,&event[pos]); 429 pos += 6; 430 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 431 } 432 433 static void hfp_emit_audio_connection_released(hfp_connection_t * hfp_connection, hci_con_handle_t sco_handle){ 434 btstack_assert(hfp_connection != NULL); 435 uint8_t event[7]; 436 int pos = 0; 437 event[pos++] = HCI_EVENT_HFP_META; 438 event[pos++] = sizeof(event) - 2; 439 event[pos++] = HFP_SUBEVENT_AUDIO_CONNECTION_RELEASED; 440 little_endian_store_16(event, pos, hfp_connection->acl_handle); 441 pos += 2; 442 little_endian_store_16(event, pos, sco_handle); 443 pos += 2; 444 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 445 } 446 447 void hfp_emit_sco_event(hfp_connection_t * hfp_connection, uint8_t status, hci_con_handle_t sco_handle, bd_addr_t addr, uint8_t negotiated_codec){ 448 btstack_assert(hfp_connection != NULL); 449 uint8_t event[15]; 450 int pos = 0; 451 event[pos++] = HCI_EVENT_HFP_META; 452 event[pos++] = sizeof(event) - 2; 453 event[pos++] = HFP_SUBEVENT_AUDIO_CONNECTION_ESTABLISHED; 454 little_endian_store_16(event, pos, hfp_connection->acl_handle); 455 pos += 2; 456 event[pos++] = status; // status 0 == OK 457 little_endian_store_16(event, pos, sco_handle); 458 pos += 2; 459 reverse_bd_addr(addr,&event[pos]); 460 pos += 6; 461 event[pos++] = negotiated_codec; 462 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 463 } 464 465 void hfp_emit_string_event(hfp_connection_t * hfp_connection, uint8_t event_subtype, const char * value){ 466 btstack_assert(hfp_connection != NULL); 467 #ifdef ENABLE_HFP_AT_MESSAGES 468 uint8_t event[256]; 469 #else 470 uint8_t event[40]; 471 #endif 472 event[0] = HCI_EVENT_HFP_META; 473 event[1] = sizeof(event) - 2; 474 event[2] = event_subtype; 475 little_endian_store_16(event, 3, hfp_connection->acl_handle); 476 uint16_t size = btstack_min(strlen(value), sizeof(event) - 6); 477 strncpy((char*)&event[5], value, size); 478 event[5 + size] = 0; 479 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 480 } 481 482 btstack_linked_list_t * hfp_get_connections(void){ 483 return (btstack_linked_list_t *) &hfp_connections; 484 } 485 486 hfp_connection_t * get_hfp_connection_context_for_rfcomm_cid(uint16_t cid){ 487 btstack_linked_list_iterator_t it; 488 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 489 while (btstack_linked_list_iterator_has_next(&it)){ 490 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 491 if (hfp_connection->rfcomm_cid == cid){ 492 return hfp_connection; 493 } 494 } 495 return NULL; 496 } 497 498 hfp_connection_t * get_hfp_connection_context_for_bd_addr(bd_addr_t bd_addr, hfp_role_t hfp_role){ 499 btstack_linked_list_iterator_t it; 500 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 501 while (btstack_linked_list_iterator_has_next(&it)){ 502 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 503 if ((memcmp(hfp_connection->remote_addr, bd_addr, 6) == 0) && (hfp_connection->local_role == hfp_role)) { 504 return hfp_connection; 505 } 506 } 507 return NULL; 508 } 509 510 hfp_connection_t * get_hfp_connection_context_for_sco_handle(uint16_t handle, hfp_role_t hfp_role){ 511 btstack_linked_list_iterator_t it; 512 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 513 while (btstack_linked_list_iterator_has_next(&it)){ 514 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 515 if ((hfp_connection->sco_handle == handle) && (hfp_connection->local_role == hfp_role)){ 516 return hfp_connection; 517 } 518 } 519 return NULL; 520 } 521 522 hfp_connection_t * get_hfp_connection_context_for_acl_handle(uint16_t handle, hfp_role_t hfp_role){ 523 btstack_linked_list_iterator_t it; 524 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 525 while (btstack_linked_list_iterator_has_next(&it)){ 526 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 527 if ((hfp_connection->acl_handle == handle) && (hfp_connection->local_role == hfp_role)){ 528 return hfp_connection; 529 } 530 } 531 return NULL; 532 } 533 534 535 static void hfp_reset_voice_recognition(hfp_connection_t * hfp_connection){ 536 btstack_assert(hfp_connection != NULL); 537 hfp_voice_recognition_activation_status_t current_vra_state = hfp_connection->vra_state; 538 hfp_connection->vra_state = HFP_VRA_VOICE_RECOGNITION_OFF; 539 540 if (current_vra_state != HFP_VRA_VOICE_RECOGNITION_OFF){ 541 hfp_emit_voice_recognition_state_event(hfp_connection, HFP_VRA_VOICE_RECOGNITION_OFF); 542 } else if (hfp_connection->vra_state_requested != HFP_VRA_VOICE_RECOGNITION_OFF){ 543 hfp_emit_voice_recognition_state_event(hfp_connection, HFP_VRA_VOICE_RECOGNITION_OFF); 544 } 545 546 hfp_connection->vra_state_requested = HFP_VRA_VOICE_RECOGNITION_OFF; 547 hfp_connection->activate_voice_recognition = false; 548 hfp_connection->deactivate_voice_recognition = false; 549 hfp_connection->enhanced_voice_recognition_enabled = false; 550 hfp_connection->ag_vra_status = 0; 551 hfp_connection->ag_vra_state = HFP_VOICE_RECOGNITION_STATE_AG_READY; 552 } 553 554 void hfp_reset_context_flags(hfp_connection_t * hfp_connection){ 555 if (!hfp_connection) return; 556 hfp_connection->ok_pending = 0; 557 hfp_connection->send_error = 0; 558 559 hfp_connection->found_equal_sign = false; 560 561 hfp_connection->change_status_update_for_individual_ag_indicators = 0; 562 hfp_connection->operator_name_changed = 0; 563 564 hfp_connection->enable_extended_audio_gateway_error_report = 0; 565 hfp_connection->extended_audio_gateway_error = 0; 566 567 // establish codecs hfp_connection 568 hfp_connection->suggested_codec = 0; 569 hfp_connection->negotiated_codec = 0; 570 hfp_connection->codec_confirmed = 0; 571 572 hfp_connection->establish_audio_connection = 0; 573 hfp_connection->call_waiting_notification_enabled = 0; 574 hfp_connection->command = HFP_CMD_NONE; 575 hfp_connection->enable_status_update_for_ag_indicators = 0xFF; 576 hfp_reset_voice_recognition(hfp_connection); 577 } 578 579 static hfp_connection_t * create_hfp_connection_context(void){ 580 hfp_connection_t * hfp_connection = btstack_memory_hfp_connection_get(); 581 if (!hfp_connection) return NULL; 582 583 hfp_connection->state = HFP_IDLE; 584 hfp_connection->call_state = HFP_CALL_IDLE; 585 hfp_connection->codecs_state = HFP_CODECS_IDLE; 586 587 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 588 hfp_connection->command = HFP_CMD_NONE; 589 590 hfp_connection->acl_handle = HCI_CON_HANDLE_INVALID; 591 hfp_connection->sco_handle = HCI_CON_HANDLE_INVALID; 592 593 hfp_reset_context_flags(hfp_connection); 594 595 btstack_linked_list_add(&hfp_connections, (btstack_linked_item_t*)hfp_connection); 596 return hfp_connection; 597 } 598 599 void hfp_finalize_connection_context(hfp_connection_t * hfp_connection){ 600 btstack_run_loop_remove_timer(&hfp_connection->hfp_timeout); 601 btstack_linked_list_remove(&hfp_connections, (btstack_linked_item_t*) hfp_connection); 602 btstack_memory_hfp_connection_free(hfp_connection); 603 } 604 605 static hfp_connection_t * hfp_create_connection(bd_addr_t bd_addr, hfp_role_t local_role){ 606 hfp_connection_t * hfp_connection = get_hfp_connection_context_for_bd_addr(bd_addr, local_role); 607 if (hfp_connection) return hfp_connection; 608 hfp_connection = create_hfp_connection_context(); 609 (void)memcpy(hfp_connection->remote_addr, bd_addr, 6); 610 hfp_connection->local_role = local_role; 611 log_info("Create HFP context %p: role %u, addr %s", hfp_connection, local_role, bd_addr_to_str(bd_addr)); 612 613 return hfp_connection; 614 } 615 616 /* @param network. 617 * 0 == no ability to reject a call. 618 * 1 == ability to reject a call. 619 */ 620 621 /* @param suported_features 622 * HF bit 0: EC and/or NR function (yes/no, 1 = yes, 0 = no) 623 * HF bit 1: Call waiting or three-way calling(yes/no, 1 = yes, 0 = no) 624 * HF bit 2: CLI presentation capability (yes/no, 1 = yes, 0 = no) 625 * HF bit 3: Voice recognition activation (yes/no, 1= yes, 0 = no) 626 * HF bit 4: Remote volume control (yes/no, 1 = yes, 0 = no) 627 * HF bit 5: Wide band speech (yes/no, 1 = yes, 0 = no) 628 */ 629 /* Bit position: 630 * AG bit 0: Three-way calling (yes/no, 1 = yes, 0 = no) 631 * AG bit 1: EC and/or NR function (yes/no, 1 = yes, 0 = no) 632 * AG bit 2: Voice recognition function (yes/no, 1 = yes, 0 = no) 633 * AG bit 3: In-band ring tone capability (yes/no, 1 = yes, 0 = no) 634 * AG bit 4: Attach a phone number to a voice tag (yes/no, 1 = yes, 0 = no) 635 * AG bit 5: Wide band speech (yes/no, 1 = yes, 0 = no) 636 */ 637 638 void hfp_create_sdp_record(uint8_t * service, uint32_t service_record_handle, uint16_t service_uuid, int rfcomm_channel_nr, const char * name){ 639 uint8_t* attribute; 640 de_create_sequence(service); 641 642 // 0x0000 "Service Record Handle" 643 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_RECORD_HANDLE); 644 de_add_number(service, DE_UINT, DE_SIZE_32, service_record_handle); 645 646 // 0x0001 "Service Class ID List" 647 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST); 648 attribute = de_push_sequence(service); 649 { 650 // "UUID for Service" 651 de_add_number(attribute, DE_UUID, DE_SIZE_16, service_uuid); 652 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_GENERIC_AUDIO); 653 } 654 de_pop_sequence(service, attribute); 655 656 // 0x0004 "Protocol Descriptor List" 657 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST); 658 attribute = de_push_sequence(service); 659 { 660 uint8_t* l2cpProtocol = de_push_sequence(attribute); 661 { 662 de_add_number(l2cpProtocol, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_L2CAP); 663 } 664 de_pop_sequence(attribute, l2cpProtocol); 665 666 uint8_t* rfcomm = de_push_sequence(attribute); 667 { 668 de_add_number(rfcomm, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_RFCOMM); // rfcomm_service 669 de_add_number(rfcomm, DE_UINT, DE_SIZE_8, rfcomm_channel_nr); // rfcomm channel 670 } 671 de_pop_sequence(attribute, rfcomm); 672 } 673 de_pop_sequence(service, attribute); 674 675 676 // 0x0005 "Public Browse Group" 677 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BROWSE_GROUP_LIST); // public browse group 678 attribute = de_push_sequence(service); 679 { 680 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PUBLIC_BROWSE_ROOT); 681 } 682 de_pop_sequence(service, attribute); 683 684 // 0x0009 "Bluetooth Profile Descriptor List" 685 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BLUETOOTH_PROFILE_DESCRIPTOR_LIST); 686 attribute = de_push_sequence(service); 687 { 688 uint8_t *sppProfile = de_push_sequence(attribute); 689 { 690 de_add_number(sppProfile, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_HANDSFREE); 691 de_add_number(sppProfile, DE_UINT, DE_SIZE_16, 0x0108); // Verision 1.8 692 } 693 de_pop_sequence(attribute, sppProfile); 694 } 695 de_pop_sequence(service, attribute); 696 697 // 0x0100 "Service Name" 698 de_add_number(service, DE_UINT, DE_SIZE_16, 0x0100); 699 de_add_data(service, DE_STRING, strlen(name), (uint8_t *) name); 700 } 701 702 static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 703 UNUSED(packet_type); // ok: handling own sdp events 704 UNUSED(channel); // ok: no channel 705 UNUSED(size); // ok: handling own sdp events 706 707 hfp_connection_t * hfp_connection = get_hfp_connection_context_for_bd_addr(hfp_sdp_query_context.remote_address, hfp_sdp_query_context.local_role); 708 if (hfp_connection == NULL) { 709 log_info("connection with %s and local role %d not found", hfp_sdp_query_context.remote_address, hfp_sdp_query_context.local_role); 710 return; 711 } 712 713 switch (hci_event_packet_get_type(packet)){ 714 case SDP_EVENT_QUERY_RFCOMM_SERVICE: 715 hfp_connection->rfcomm_channel_nr = sdp_event_query_rfcomm_service_get_rfcomm_channel(packet); 716 break; 717 case SDP_EVENT_QUERY_COMPLETE: 718 if (hfp_connection->rfcomm_channel_nr > 0){ 719 hfp_connection->state = HFP_W4_RFCOMM_CONNECTED; 720 btstack_packet_handler_t packet_handler; 721 switch (hfp_connection->local_role){ 722 case HFP_ROLE_AG: 723 packet_handler = hfp_ag_rfcomm_packet_handler; 724 break; 725 case HFP_ROLE_HF: 726 packet_handler = hfp_hf_rfcomm_packet_handler; 727 break; 728 default: 729 btstack_assert(false); 730 return; 731 } 732 733 rfcomm_create_channel(packet_handler, hfp_connection->remote_addr, hfp_connection->rfcomm_channel_nr, NULL); 734 735 } else { 736 hfp_connection->state = HFP_IDLE; 737 uint8_t status = sdp_event_query_complete_get_status(packet); 738 if (status == ERROR_CODE_SUCCESS){ 739 // report service not found 740 status = SDP_SERVICE_NOT_FOUND; 741 } 742 hfp_emit_slc_connection_event(hfp_connection, status, HCI_CON_HANDLE_INVALID, hfp_connection->remote_addr); 743 log_info("rfcomm service not found, status 0x%02x", status); 744 } 745 746 // register the SDP Query request to check if there is another connection waiting for the query 747 // ignore ERROR_CODE_COMMAND_DISALLOWED because in that case, we already have requested an SDP callback 748 (void) sdp_client_register_query_callback(&hfp_sdp_query_request); 749 break; 750 default: 751 break; 752 } 753 } 754 755 // returns 0 if unexpected error or no other link options remained, otherwise 1 756 static int hfp_handle_failed_sco_connection(uint8_t status){ 757 758 if (!hfp_sco_establishment_active){ 759 log_info("(e)SCO Connection failed but not started by us"); 760 return 0; 761 } 762 763 log_info("(e)SCO Connection failed 0x%02x", status); 764 switch (status){ 765 case ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE: 766 case ERROR_CODE_UNSPECIFIED_ERROR: 767 case ERROR_CODE_CONNECTION_REJECTED_DUE_TO_LIMITED_RESOURCES: 768 break; 769 default: 770 return 0; 771 } 772 773 // note: eSCO_S4 supported flag not available, but it's only relevant for highest CVSD link setting (and the current failed) 774 hfp_link_settings_t next_setting = hfp_next_link_setting_for_connection(hfp_sco_establishment_active->link_setting, hfp_sco_establishment_active, false); 775 776 // handle no valid setting found 777 if (next_setting == HFP_LINK_SETTINGS_NONE) { 778 if (hfp_sco_establishment_active->negotiated_codec == HFP_CODEC_MSBC){ 779 log_info("T2/T1 failed, fallback to CVSD - D1"); 780 hfp_sco_establishment_active->negotiated_codec = HFP_CODEC_CVSD; 781 hfp_sco_establishment_active->sco_for_msbc_failed = 1; 782 hfp_sco_establishment_active->command = HFP_CMD_AG_SEND_COMMON_CODEC; 783 hfp_sco_establishment_active->link_setting = HFP_LINK_SETTINGS_D1; 784 } else { 785 // no other options 786 return 0; 787 } 788 } 789 790 log_info("e)SCO Connection: try new link_setting %d", next_setting); 791 hfp_sco_establishment_active->establish_audio_connection = 1; 792 hfp_sco_establishment_active->link_setting = next_setting; 793 hfp_sco_establishment_active = NULL; 794 return 1; 795 } 796 797 void hfp_handle_hci_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size, hfp_role_t local_role){ 798 UNUSED(packet_type); 799 UNUSED(channel); // ok: no channel 800 UNUSED(size); 801 802 bd_addr_t event_addr; 803 hci_con_handle_t handle; 804 hfp_connection_t * hfp_connection = NULL; 805 uint8_t status; 806 807 log_debug("HFP HCI event handler type %u, event type %x, size %u", packet_type, hci_event_packet_get_type(packet), size); 808 809 switch (hci_event_packet_get_type(packet)) { 810 811 case HCI_EVENT_CONNECTION_REQUEST: 812 switch(hci_event_connection_request_get_link_type(packet)){ 813 case 0: // SCO 814 case 2: // eSCO 815 hci_event_connection_request_get_bd_addr(packet, event_addr); 816 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 817 if (!hfp_connection) break; 818 if (hci_event_connection_request_get_link_type(packet) == 2){ 819 hfp_connection->accept_sco = 2; 820 } else { 821 hfp_connection->accept_sco = 1; 822 } 823 #ifdef ENABLE_CC256X_ASSISTED_HFP 824 hfp_cc256x_prepare_for_sco(hfp_connection); 825 #endif 826 #ifdef ENABLE_BCM_PCM_WBS 827 hfp_bcm_prepare_for_sco(hfp_connection); 828 #endif 829 log_info("accept sco %u\n", hfp_connection->accept_sco); 830 hfp_sco_establishment_active = hfp_connection; 831 break; 832 default: 833 break; 834 } 835 break; 836 837 case HCI_EVENT_COMMAND_STATUS: 838 if (hci_event_command_status_get_command_opcode(packet) == hci_setup_synchronous_connection.opcode) { 839 if (hfp_sco_establishment_active == NULL) break; 840 status = hci_event_command_status_get_status(packet); 841 if (status == ERROR_CODE_SUCCESS) break; 842 843 hfp_connection = hfp_sco_establishment_active; 844 if (hfp_handle_failed_sco_connection(status)) break; 845 hfp_connection->establish_audio_connection = 0; 846 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 847 hfp_emit_sco_event(hfp_connection, status, 0, hfp_connection->remote_addr, hfp_connection->negotiated_codec); 848 } 849 break; 850 851 case HCI_EVENT_SYNCHRONOUS_CONNECTION_COMPLETE:{ 852 if (hfp_sco_establishment_active == NULL) break; 853 hci_event_synchronous_connection_complete_get_bd_addr(packet, event_addr); 854 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 855 if (!hfp_connection) { 856 log_error("HFP: connection does not exist for remote with addr %s.", bd_addr_to_str(event_addr)); 857 return; 858 } 859 860 status = hci_event_synchronous_connection_complete_get_status(packet); 861 if (status != ERROR_CODE_SUCCESS){ 862 hfp_connection->accept_sco = 0; 863 if (hfp_handle_failed_sco_connection(status)) break; 864 865 hfp_connection->establish_audio_connection = 0; 866 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 867 hfp_emit_sco_event(hfp_connection, status, 0, event_addr, hfp_connection->negotiated_codec); 868 break; 869 } 870 871 uint16_t sco_handle = hci_event_synchronous_connection_complete_get_handle(packet); 872 uint8_t link_type = hci_event_synchronous_connection_complete_get_link_type(packet); 873 uint8_t transmission_interval = hci_event_synchronous_connection_complete_get_transmission_interval(packet); // measured in slots 874 uint8_t retransmission_interval = hci_event_synchronous_connection_complete_get_retransmission_interval(packet);// measured in slots 875 uint16_t rx_packet_length = hci_event_synchronous_connection_complete_get_rx_packet_length(packet); // measured in bytes 876 uint16_t tx_packet_length = hci_event_synchronous_connection_complete_get_tx_packet_length(packet); // measured in bytes 877 878 switch (link_type){ 879 case 0x00: 880 log_info("SCO Connection established."); 881 if (transmission_interval != 0) log_error("SCO Connection: transmission_interval not zero: %d.", transmission_interval); 882 if (retransmission_interval != 0) log_error("SCO Connection: retransmission_interval not zero: %d.", retransmission_interval); 883 if (rx_packet_length != 0) log_error("SCO Connection: rx_packet_length not zero: %d.", rx_packet_length); 884 if (tx_packet_length != 0) log_error("SCO Connection: tx_packet_length not zero: %d.", tx_packet_length); 885 break; 886 case 0x02: 887 log_info("eSCO Connection established. \n"); 888 break; 889 default: 890 log_error("(e)SCO reserved link_type 0x%2x", link_type); 891 break; 892 } 893 894 log_info("sco_handle 0x%2x, address %s, transmission_interval %u slots, retransmission_interval %u slots, " 895 " rx_packet_length %u bytes, tx_packet_length %u bytes, air_mode 0x%2x (0x02 == CVSD)\n", sco_handle, 896 bd_addr_to_str(event_addr), transmission_interval, retransmission_interval, rx_packet_length, tx_packet_length, 897 hci_event_synchronous_connection_complete_get_air_mode(packet)); 898 899 if (hfp_connection->state == HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN){ 900 log_info("SCO about to disconnect: HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN"); 901 hfp_connection->state = HFP_W2_DISCONNECT_SCO; 902 break; 903 } 904 hfp_connection->sco_handle = sco_handle; 905 hfp_connection->establish_audio_connection = 0; 906 907 hfp_connection->state = HFP_AUDIO_CONNECTION_ESTABLISHED; 908 909 switch (hfp_connection->vra_state){ 910 case HFP_VRA_VOICE_RECOGNITION_ACTIVATED: 911 hfp_connection->ag_audio_connection_opened_before_vra = false; 912 break; 913 default: 914 hfp_connection->ag_audio_connection_opened_before_vra = true; 915 break; 916 } 917 hfp_emit_sco_event(hfp_connection, status, sco_handle, event_addr, hfp_connection->negotiated_codec); 918 break; 919 } 920 921 case HCI_EVENT_DISCONNECTION_COMPLETE: 922 handle = little_endian_read_16(packet,3); 923 hfp_connection = get_hfp_connection_context_for_sco_handle(handle, local_role); 924 925 if (!hfp_connection) break; 926 927 #ifdef ENABLE_CC256X_ASSISTED_HFP 928 hfp_connection->cc256x_send_wbs_disassociate = true; 929 #endif 930 #ifdef ENABLE_BCM_PCM_WBS 931 hfp_connection->bcm_send_disable_wbs = true; 932 #endif 933 if (hfp_connection->sco_handle == handle){ 934 hfp_connection->sco_handle = HCI_CON_HANDLE_INVALID; 935 hfp_connection->release_audio_connection = 0; 936 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 937 hfp_emit_audio_connection_released(hfp_connection, handle); 938 939 hfp_connection->ag_audio_connection_opened_before_vra = false; 940 941 if (hfp_connection->acl_handle == HCI_CON_HANDLE_INVALID){ 942 hfp_reset_voice_recognition(hfp_connection); 943 hfp_emit_event(hfp_connection, HFP_SUBEVENT_SERVICE_LEVEL_CONNECTION_RELEASED, 0); 944 hfp_finalize_connection_context(hfp_connection); 945 } else if (hfp_connection->release_slc_connection == 1){ 946 hfp_connection->release_slc_connection = 0; 947 hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM; 948 rfcomm_disconnect(hfp_connection->acl_handle); 949 } 950 } 951 952 if (hfp_connection->state == HFP_W4_SCO_DISCONNECTED_TO_SHUTDOWN){ 953 // RFCOMM already closed -> remote power off 954 #if defined(ENABLE_CC256X_ASSISTED_HFP) || defined (ENABLE_BCM_PCM_WBS) 955 hfp_connection->state = HFP_W4_WBS_SHUTDOWN; 956 #else 957 hfp_finalize_connection_context(hfp_connection); 958 #endif 959 break; 960 } 961 break; 962 963 default: 964 break; 965 } 966 } 967 968 969 void hfp_handle_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size, hfp_role_t local_role){ 970 UNUSED(packet_type); 971 UNUSED(channel); // ok: no channel 972 UNUSED(size); 973 974 bd_addr_t event_addr; 975 uint16_t rfcomm_cid; 976 hfp_connection_t * hfp_connection = NULL; 977 uint8_t status; 978 979 log_debug("HFP packet_handler type %u, event type %x, size %u", packet_type, hci_event_packet_get_type(packet), size); 980 981 switch (hci_event_packet_get_type(packet)) { 982 983 case RFCOMM_EVENT_INCOMING_CONNECTION: 984 // data: event (8), len(8), address(48), channel (8), rfcomm_cid (16) 985 rfcomm_event_incoming_connection_get_bd_addr(packet, event_addr); 986 hfp_connection = hfp_create_connection(event_addr, local_role); 987 if (!hfp_connection){ 988 log_info("hfp: no memory to accept incoming connection - decline"); 989 rfcomm_decline_connection(rfcomm_event_incoming_connection_get_rfcomm_cid(packet)); 990 return; 991 } 992 if (hfp_connection->state != HFP_IDLE) { 993 log_error("hfp: incoming connection but not idle, reject"); 994 rfcomm_decline_connection(rfcomm_event_incoming_connection_get_rfcomm_cid(packet)); 995 return; 996 } 997 998 hfp_connection->rfcomm_cid = rfcomm_event_incoming_connection_get_rfcomm_cid(packet); 999 hfp_connection->state = HFP_W4_RFCOMM_CONNECTED; 1000 rfcomm_accept_connection(hfp_connection->rfcomm_cid); 1001 break; 1002 1003 case RFCOMM_EVENT_CHANNEL_OPENED: 1004 // data: event(8), len(8), status (8), address (48), handle(16), server channel(8), rfcomm_cid(16), max frame size(16) 1005 1006 rfcomm_event_channel_opened_get_bd_addr(packet, event_addr); 1007 status = rfcomm_event_channel_opened_get_status(packet); 1008 1009 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 1010 if (!hfp_connection || (hfp_connection->state != HFP_W4_RFCOMM_CONNECTED)) return; 1011 1012 if (status) { 1013 hfp_emit_slc_connection_event(hfp_connection, status, rfcomm_event_channel_opened_get_con_handle(packet), event_addr); 1014 hfp_finalize_connection_context(hfp_connection); 1015 } else { 1016 hfp_connection->acl_handle = rfcomm_event_channel_opened_get_con_handle(packet); 1017 hfp_connection->rfcomm_cid = rfcomm_event_channel_opened_get_rfcomm_cid(packet); 1018 bd_addr_copy(hfp_connection->remote_addr, event_addr); 1019 1020 switch (hfp_connection->state){ 1021 case HFP_W4_RFCOMM_CONNECTED: 1022 hfp_connection->state = HFP_EXCHANGE_SUPPORTED_FEATURES; 1023 break; 1024 case HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN: 1025 hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM; 1026 break; 1027 default: 1028 break; 1029 } 1030 rfcomm_request_can_send_now_event(hfp_connection->rfcomm_cid); 1031 } 1032 break; 1033 1034 case RFCOMM_EVENT_CHANNEL_CLOSED: 1035 rfcomm_cid = little_endian_read_16(packet,2); 1036 hfp_connection = get_hfp_connection_context_for_rfcomm_cid(rfcomm_cid); 1037 if (!hfp_connection) break; 1038 switch (hfp_connection->state){ 1039 case HFP_W4_RFCOMM_DISCONNECTED_AND_RESTART: 1040 hfp_connection->acl_handle = HCI_CON_HANDLE_INVALID; 1041 hfp_connection->state = HFP_IDLE; 1042 hfp_establish_service_level_connection(hfp_connection->remote_addr, hfp_connection->service_uuid, local_role); 1043 break; 1044 1045 case HFP_AUDIO_CONNECTION_ESTABLISHED: 1046 // service connection was released, this implicitly releases audio connection as well 1047 hfp_connection->release_audio_connection = 0; 1048 hfp_connection->acl_handle = HCI_CON_HANDLE_INVALID; 1049 hfp_connection->state = HFP_W4_SCO_DISCONNECTED_TO_SHUTDOWN; 1050 gap_disconnect(hfp_connection->sco_handle); 1051 break; 1052 1053 default: 1054 // regular case 1055 hfp_reset_voice_recognition(hfp_connection); 1056 hfp_emit_event(hfp_connection, HFP_SUBEVENT_SERVICE_LEVEL_CONNECTION_RELEASED, 0); 1057 hfp_finalize_connection_context(hfp_connection); 1058 break; 1059 } 1060 break; 1061 1062 default: 1063 break; 1064 } 1065 } 1066 // translates command string into hfp_command_t CMD 1067 1068 typedef struct { 1069 const char * command; 1070 hfp_command_t command_id; 1071 } hfp_command_entry_t; 1072 1073 static hfp_command_entry_t hfp_ag_commmand_table[] = { 1074 { "AT+BAC=", HFP_CMD_AVAILABLE_CODECS }, 1075 { "AT+BCC", HFP_CMD_TRIGGER_CODEC_CONNECTION_SETUP }, 1076 { "AT+BCS=", HFP_CMD_HF_CONFIRMED_CODEC }, 1077 { "AT+BIA=", HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE, }, // +BIA:<enabled>,,<enabled>,,,<enabled> 1078 { "AT+BIEV=", HFP_CMD_HF_INDICATOR_STATUS }, 1079 { "AT+BIND=", HFP_CMD_LIST_GENERIC_STATUS_INDICATORS }, 1080 { "AT+BIND=?", HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS }, 1081 { "AT+BIND?", HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE }, 1082 { "AT+BINP=", HFP_CMD_HF_REQUEST_PHONE_NUMBER }, 1083 { "AT+BLDN", HFP_CMD_REDIAL_LAST_NUMBER }, 1084 { "AT+BRSF=", HFP_CMD_SUPPORTED_FEATURES }, 1085 { "AT+BTRH=", HFP_CMD_RESPONSE_AND_HOLD_COMMAND }, 1086 { "AT+BTRH?", HFP_CMD_RESPONSE_AND_HOLD_QUERY }, 1087 { "AT+BVRA=", HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION }, 1088 { "AT+CCWA=", HFP_CMD_ENABLE_CALL_WAITING_NOTIFICATION}, 1089 { "AT+CHLD=", HFP_CMD_CALL_HOLD }, 1090 { "AT+CHLD=?", HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES }, 1091 { "AT+CHUP", HFP_CMD_HANG_UP_CALL }, 1092 { "AT+CIND=?", HFP_CMD_RETRIEVE_AG_INDICATORS }, 1093 { "AT+CIND?", HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS }, 1094 { "AT+CLCC", HFP_CMD_LIST_CURRENT_CALLS }, 1095 { "AT+CLIP=", HFP_CMD_ENABLE_CLIP}, 1096 { "AT+CMEE=", HFP_CMD_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR}, 1097 { "AT+CMER=", HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE }, 1098 { "AT+CNUM", HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION }, 1099 { "AT+COPS=", HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT }, 1100 { "AT+COPS?", HFP_CMD_QUERY_OPERATOR_SELECTION_NAME }, 1101 { "AT+NREC=", HFP_CMD_TURN_OFF_EC_AND_NR, }, 1102 { "AT+VGM=", HFP_CMD_SET_MICROPHONE_GAIN }, 1103 { "AT+VGS=", HFP_CMD_SET_SPEAKER_GAIN }, 1104 { "AT+VTS=", HFP_CMD_TRANSMIT_DTMF_CODES }, 1105 { "ATA", HFP_CMD_CALL_ANSWERED }, 1106 }; 1107 1108 static hfp_command_entry_t hfp_hf_commmand_table[] = { 1109 { "+BCS:", HFP_CMD_AG_SUGGESTED_CODEC }, 1110 { "+BIND:", HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS }, 1111 { "+BINP", HFP_CMD_AG_SENT_PHONE_NUMBER }, 1112 { "+BRSF:", HFP_CMD_SUPPORTED_FEATURES }, 1113 { "+BSIR:", HFP_CMD_CHANGE_IN_BAND_RING_TONE_SETTING }, 1114 { "+BTRH:", HFP_CMD_RESPONSE_AND_HOLD_STATUS }, 1115 { "+BVRA:", HFP_CMD_AG_ACTIVATE_VOICE_RECOGNITION }, 1116 { "+CCWA:", HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE, }, 1117 { "+CHLD:", HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES }, 1118 { "+CIEV:", HFP_CMD_TRANSFER_AG_INDICATOR_STATUS}, 1119 { "+CIND:", HFP_CMD_RETRIEVE_AG_INDICATORS_GENERIC }, 1120 { "+CLCC:", HFP_CMD_LIST_CURRENT_CALLS }, 1121 { "+CLIP:", HFP_CMD_AG_SENT_CLIP_INFORMATION }, 1122 { "+CME ERROR:", HFP_CMD_EXTENDED_AUDIO_GATEWAY_ERROR }, 1123 { "+CNUM:", HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION}, 1124 { "+COPS:", HFP_CMD_QUERY_OPERATOR_SELECTION_NAME }, 1125 { "+VGM:", HFP_CMD_SET_MICROPHONE_GAIN }, 1126 { "+VGS:", HFP_CMD_SET_SPEAKER_GAIN}, 1127 { "ERROR", HFP_CMD_ERROR}, 1128 { "NOP", HFP_CMD_NONE}, // dummy command used by unit tests 1129 { "OK", HFP_CMD_OK }, 1130 { "RING", HFP_CMD_RING }, 1131 }; 1132 1133 static hfp_command_t parse_command(const char * line_buffer, int isHandsFree){ 1134 1135 // table lookup based on role 1136 uint16_t num_entries; 1137 hfp_command_entry_t * table; 1138 if (isHandsFree == 0){ 1139 table = hfp_ag_commmand_table; 1140 num_entries = sizeof(hfp_ag_commmand_table) / sizeof(hfp_command_entry_t); 1141 } else { 1142 table = hfp_hf_commmand_table; 1143 num_entries = sizeof(hfp_hf_commmand_table) / sizeof(hfp_command_entry_t); 1144 } 1145 // binary search 1146 uint16_t left = 0; 1147 uint16_t right = num_entries - 1; 1148 while (left <= right){ 1149 uint16_t middle = left + (right - left) / 2; 1150 hfp_command_entry_t *entry = &table[middle]; 1151 int match = strcmp(line_buffer, entry->command); 1152 if (match < 0){ 1153 // search term is lower than middle element 1154 if (right == 0) break; 1155 right = middle - 1; 1156 } else if (match == 0){ 1157 return entry->command_id; 1158 } else { 1159 // search term is higher than middle element 1160 left = middle + 1; 1161 } 1162 } 1163 1164 // note: if parser in CMD_HEADER state would treats digits and maybe '+' as separator, match on "ATD" would work. 1165 // note: phone number is currently expected in line_buffer[3..] 1166 // prefix match on 'ATD', AG only 1167 if ((isHandsFree == 0) && (strncmp(line_buffer, HFP_CALL_PHONE_NUMBER, strlen(HFP_CALL_PHONE_NUMBER)) == 0)){ 1168 return HFP_CMD_CALL_PHONE_NUMBER; 1169 } 1170 1171 // Valid looking, but unknown commands/responses 1172 if ((isHandsFree == 0) && (strncmp(line_buffer, "AT+", 3) == 0)){ 1173 return HFP_CMD_UNKNOWN; 1174 } 1175 1176 if ((isHandsFree != 0) && (strncmp(line_buffer, "+", 1) == 0)){ 1177 return HFP_CMD_UNKNOWN; 1178 } 1179 1180 return HFP_CMD_NONE; 1181 } 1182 1183 static void hfp_parser_store_byte(hfp_connection_t * hfp_connection, uint8_t byte){ 1184 if ((hfp_connection->line_size + 1 ) >= HFP_MAX_INDICATOR_DESC_SIZE) return; 1185 hfp_connection->line_buffer[hfp_connection->line_size++] = byte; 1186 hfp_connection->line_buffer[hfp_connection->line_size] = 0; 1187 } 1188 static int hfp_parser_is_buffer_empty(hfp_connection_t * hfp_connection){ 1189 return hfp_connection->line_size == 0; 1190 } 1191 1192 static int hfp_parser_is_end_of_line(uint8_t byte){ 1193 return (byte == '\n') || (byte == '\r'); 1194 } 1195 1196 static void hfp_parser_reset_line_buffer(hfp_connection_t *hfp_connection) { 1197 hfp_connection->line_size = 0; 1198 } 1199 1200 static void hfp_parser_store_if_token(hfp_connection_t * hfp_connection, uint8_t byte){ 1201 switch (byte){ 1202 case ',': 1203 case '-': 1204 case ';': 1205 case '(': 1206 case ')': 1207 case '\n': 1208 case '\r': 1209 break; 1210 default: 1211 hfp_parser_store_byte(hfp_connection, byte); 1212 break; 1213 } 1214 } 1215 1216 static bool hfp_parser_is_separator( uint8_t byte){ 1217 switch (byte){ 1218 case ',': 1219 case '-': 1220 case ';': 1221 case '\n': 1222 case '\r': 1223 return true; 1224 default: 1225 return false; 1226 } 1227 } 1228 1229 static bool hfp_parse_byte(hfp_connection_t * hfp_connection, uint8_t byte, int isHandsFree){ 1230 1231 // handle doubles quotes 1232 if (byte == '"'){ 1233 hfp_connection->parser_quoted = !hfp_connection->parser_quoted; 1234 return true; 1235 } 1236 if (hfp_connection->parser_quoted) { 1237 hfp_parser_store_byte(hfp_connection, byte); 1238 return true; 1239 } 1240 1241 // ignore spaces outside command or double quotes (required e.g. for '+CME ERROR:..") command 1242 if ((byte == ' ') && (hfp_connection->parser_state != HFP_PARSER_CMD_HEADER)) return true; 1243 1244 bool processed = true; 1245 1246 switch (hfp_connection->parser_state) { 1247 case HFP_PARSER_CMD_HEADER: 1248 switch (byte) { 1249 case '\n': 1250 case '\r': 1251 case ';': 1252 // ignore separator 1253 break; 1254 case ':': 1255 case '?': 1256 // store separator 1257 hfp_parser_store_byte(hfp_connection, byte); 1258 break; 1259 case '=': 1260 // equal sign: remember and wait for next char to decided between '=?' and '=\?' 1261 hfp_connection->found_equal_sign = true; 1262 hfp_parser_store_byte(hfp_connection, byte); 1263 return true; 1264 default: 1265 // store if not lookahead 1266 if (!hfp_connection->found_equal_sign) { 1267 hfp_parser_store_byte(hfp_connection, byte); 1268 return true; 1269 } 1270 // mark as lookahead 1271 processed = false; 1272 break; 1273 } 1274 1275 // ignore empty tokens 1276 if (hfp_parser_is_buffer_empty(hfp_connection)) return true; 1277 1278 // parse 1279 hfp_connection->command = parse_command((char *)hfp_connection->line_buffer, isHandsFree); 1280 1281 // pick +CIND version based on connection state: descriptions during SLC vs. states later 1282 if (hfp_connection->command == HFP_CMD_RETRIEVE_AG_INDICATORS_GENERIC){ 1283 switch(hfp_connection->state){ 1284 case HFP_W4_RETRIEVE_INDICATORS_STATUS: 1285 hfp_connection->command = HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS; 1286 break; 1287 case HFP_W4_RETRIEVE_INDICATORS: 1288 hfp_connection->command = HFP_CMD_RETRIEVE_AG_INDICATORS; 1289 break; 1290 default: 1291 hfp_connection->command = HFP_CMD_UNKNOWN; 1292 break; 1293 } 1294 } 1295 1296 log_info("command string '%s', handsfree %u -> cmd id %u", (char *)hfp_connection->line_buffer, isHandsFree, hfp_connection->command); 1297 1298 // next state 1299 hfp_connection->found_equal_sign = false; 1300 hfp_parser_reset_line_buffer(hfp_connection); 1301 hfp_connection->parser_state = HFP_PARSER_CMD_SEQUENCE; 1302 1303 return processed; 1304 1305 case HFP_PARSER_CMD_SEQUENCE: 1306 // handle empty fields 1307 if ((byte == ',' ) && (hfp_connection->line_size == 0)){ 1308 hfp_connection->line_buffer[0] = 0; 1309 hfp_connection->ignore_value = 1; 1310 parse_sequence(hfp_connection); 1311 return true; 1312 } 1313 1314 hfp_parser_store_if_token(hfp_connection, byte); 1315 if (!hfp_parser_is_separator(byte)) return true; 1316 1317 // ignore empty tokens 1318 if (hfp_parser_is_buffer_empty(hfp_connection) && (hfp_connection->ignore_value == 0)) return true; 1319 1320 parse_sequence(hfp_connection); 1321 1322 hfp_parser_reset_line_buffer(hfp_connection); 1323 1324 switch (hfp_connection->command){ 1325 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1326 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1327 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1328 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1329 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1330 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1331 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1332 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1333 case HFP_CMD_HF_INDICATOR_STATUS: 1334 hfp_connection->parser_state = HFP_PARSER_SECOND_ITEM; 1335 break; 1336 default: 1337 break; 1338 } 1339 return true; 1340 1341 case HFP_PARSER_SECOND_ITEM: 1342 1343 hfp_parser_store_if_token(hfp_connection, byte); 1344 if (!hfp_parser_is_separator(byte)) return true; 1345 1346 switch (hfp_connection->command){ 1347 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1348 log_info("format %s, ", hfp_connection->line_buffer); 1349 hfp_connection->network_operator.format = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1350 break; 1351 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1352 log_info("format %s \n", hfp_connection->line_buffer); 1353 hfp_connection->network_operator.format = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1354 break; 1355 case HFP_CMD_LIST_GENERIC_STATUS_INDICATORS: 1356 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS: 1357 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1358 hfp_connection->generic_status_indicators[hfp_connection->parser_item_index].state = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1359 break; 1360 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1361 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1362 log_info("%d \n", hfp_connection->ag_indicators[hfp_connection->parser_item_index].status); 1363 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status_changed = 1; 1364 break; 1365 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1366 hfp_connection->ag_indicators[hfp_connection->parser_item_index].min_range = btstack_atoi((char *)hfp_connection->line_buffer); 1367 log_info("%s, ", hfp_connection->line_buffer); 1368 break; 1369 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1370 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1371 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1372 hfp_connection->bnip_type = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1373 break; 1374 case HFP_CMD_HF_INDICATOR_STATUS: 1375 hfp_connection->parser_indicator_value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1376 break; 1377 default: 1378 break; 1379 } 1380 1381 hfp_parser_reset_line_buffer(hfp_connection); 1382 1383 hfp_connection->parser_state = HFP_PARSER_THIRD_ITEM; 1384 1385 return true; 1386 1387 case HFP_PARSER_THIRD_ITEM: 1388 1389 hfp_parser_store_if_token(hfp_connection, byte); 1390 if (!hfp_parser_is_separator(byte)) return true; 1391 1392 switch (hfp_connection->command){ 1393 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1394 strncpy(hfp_connection->network_operator.name, (char *)hfp_connection->line_buffer, HFP_MAX_NETWORK_OPERATOR_NAME_SIZE); 1395 hfp_connection->network_operator.name[HFP_MAX_NETWORK_OPERATOR_NAME_SIZE - 1] = 0; 1396 log_info("name %s\n", hfp_connection->line_buffer); 1397 break; 1398 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1399 hfp_connection->ag_indicators[hfp_connection->parser_item_index].max_range = btstack_atoi((char *)hfp_connection->line_buffer); 1400 hfp_next_indicators_index(hfp_connection); 1401 hfp_connection->ag_indicators_nr = hfp_connection->parser_item_index; 1402 log_info("%s)\n", hfp_connection->line_buffer); 1403 break; 1404 default: 1405 break; 1406 } 1407 1408 hfp_parser_reset_line_buffer(hfp_connection); 1409 1410 if (hfp_connection->command == HFP_CMD_RETRIEVE_AG_INDICATORS){ 1411 hfp_connection->parser_state = HFP_PARSER_CMD_SEQUENCE; 1412 } else { 1413 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 1414 } 1415 return true; 1416 1417 default: 1418 btstack_assert(false); 1419 return true; 1420 } 1421 } 1422 1423 void hfp_parse(hfp_connection_t * hfp_connection, uint8_t byte, int isHandsFree){ 1424 bool processed = false; 1425 while (!processed){ 1426 processed = hfp_parse_byte(hfp_connection, byte, isHandsFree); 1427 } 1428 // reset parser state on end-of-line 1429 if (hfp_parser_is_end_of_line(byte)){ 1430 hfp_connection->parser_item_index = 0; 1431 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 1432 } 1433 } 1434 1435 static void parse_sequence(hfp_connection_t * hfp_connection){ 1436 int value; 1437 switch (hfp_connection->command){ 1438 case HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS: 1439 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1440 int i; 1441 switch (hfp_connection->parser_item_index){ 1442 case 0: 1443 for (i=0;i<hfp_connection->generic_status_indicators_nr;i++){ 1444 if (hfp_connection->generic_status_indicators[i].uuid == value){ 1445 hfp_connection->parser_indicator_index = i; 1446 break; 1447 } 1448 } 1449 break; 1450 case 1: 1451 if (hfp_connection->parser_indicator_index <0) break; 1452 hfp_connection->generic_status_indicators[hfp_connection->parser_indicator_index].state = value; 1453 log_info("HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS set indicator at index %u, to %u\n", 1454 hfp_connection->parser_item_index, value); 1455 break; 1456 default: 1457 break; 1458 } 1459 hfp_next_indicators_index(hfp_connection); 1460 break; 1461 1462 case HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION: 1463 switch(hfp_connection->parser_item_index){ 1464 case 0: 1465 // <alpha>: This optional field is not supported, and shall be left blank. 1466 break; 1467 case 1: 1468 // <number>: Quoted string containing the phone number in the format specified by <type>. 1469 strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number)); 1470 hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0; 1471 break; 1472 case 2: 1473 /* 1474 <type> field specifies the format of the phone number provided, and can be one of the following values: 1475 - 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. 1476 - 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. 1477 - values 160-175: National number. No prefix nor escape digits included. 1478 */ 1479 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1480 hfp_connection->bnip_type = value; 1481 break; 1482 case 3: 1483 // <speed>: This optional field is not supported, and shall be left blank. 1484 break; 1485 case 4: 1486 // <service>: Indicates which service this phone number relates to. Shall be either 4 (voice) or 5 (fax). 1487 default: 1488 break; 1489 } 1490 // index > 2 are ignored in switch above 1491 hfp_connection->parser_item_index++; 1492 break; 1493 case HFP_CMD_LIST_CURRENT_CALLS: 1494 switch(hfp_connection->parser_item_index){ 1495 case 0: 1496 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1497 hfp_connection->clcc_idx = value; 1498 break; 1499 case 1: 1500 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1501 hfp_connection->clcc_dir = value; 1502 break; 1503 case 2: 1504 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1505 hfp_connection->clcc_status = value; 1506 break; 1507 case 3: 1508 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1509 hfp_connection->clcc_mode = value; 1510 break; 1511 case 4: 1512 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1513 hfp_connection->clcc_mpty = value; 1514 break; 1515 case 5: 1516 strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number)); 1517 hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0; 1518 break; 1519 case 6: 1520 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1521 hfp_connection->bnip_type = value; 1522 break; 1523 default: 1524 break; 1525 } 1526 // index > 6 are ignored in switch above 1527 hfp_connection->parser_item_index++; 1528 break; 1529 case HFP_CMD_SET_MICROPHONE_GAIN: 1530 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1531 hfp_connection->microphone_gain = value; 1532 log_info("hfp parse HFP_CMD_SET_MICROPHONE_GAIN %d\n", value); 1533 break; 1534 case HFP_CMD_SET_SPEAKER_GAIN: 1535 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1536 hfp_connection->speaker_gain = value; 1537 log_info("hfp parse HFP_CMD_SET_SPEAKER_GAIN %d\n", value); 1538 break; 1539 case HFP_CMD_TURN_OFF_EC_AND_NR: 1540 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1541 hfp_connection->ag_echo_and_noise_reduction = value; 1542 log_info("hfp parse HFP_CMD_TURN_OFF_EC_AND_NR %d\n", value); 1543 break; 1544 case HFP_CMD_CHANGE_IN_BAND_RING_TONE_SETTING: 1545 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1546 hfp_connection->remote_supported_features = store_bit(hfp_connection->remote_supported_features, HFP_AGSF_IN_BAND_RING_TONE, value); 1547 log_info("hfp parse HFP_CHANGE_IN_BAND_RING_TONE_SETTING %d\n", value); 1548 break; 1549 case HFP_CMD_HF_CONFIRMED_CODEC: 1550 hfp_connection->codec_confirmed = btstack_atoi((char*)hfp_connection->line_buffer); 1551 log_info("hfp parse HFP_CMD_HF_CONFIRMED_CODEC %d\n", hfp_connection->codec_confirmed); 1552 break; 1553 case HFP_CMD_AG_SUGGESTED_CODEC: 1554 hfp_connection->suggested_codec = btstack_atoi((char*)hfp_connection->line_buffer); 1555 log_info("hfp parse HFP_CMD_AG_SUGGESTED_CODEC %d\n", hfp_connection->suggested_codec); 1556 break; 1557 case HFP_CMD_SUPPORTED_FEATURES: 1558 hfp_connection->remote_supported_features = btstack_atoi((char*)hfp_connection->line_buffer); 1559 log_info("Parsed supported feature %d\n", (int) hfp_connection->remote_supported_features); 1560 break; 1561 case HFP_CMD_AVAILABLE_CODECS: 1562 log_info("Parsed codec %s\n", hfp_connection->line_buffer); 1563 hfp_connection->remote_codecs[hfp_connection->parser_item_index] = (uint16_t)btstack_atoi((char*)hfp_connection->line_buffer); 1564 hfp_next_codec_index(hfp_connection); 1565 hfp_connection->remote_codecs_nr = hfp_connection->parser_item_index; 1566 break; 1567 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1568 strncpy((char *)hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, (char *)hfp_connection->line_buffer, HFP_MAX_INDICATOR_DESC_SIZE); 1569 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name[HFP_MAX_INDICATOR_DESC_SIZE-1] = 0; 1570 hfp_connection->ag_indicators[hfp_connection->parser_item_index].index = hfp_connection->parser_item_index+1; 1571 log_info("Indicator %d: %s (", hfp_connection->ag_indicators_nr+1, hfp_connection->line_buffer); 1572 break; 1573 case HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS: 1574 log_info("Parsed Indicator %d with status: %s\n", hfp_connection->parser_item_index+1, hfp_connection->line_buffer); 1575 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status = btstack_atoi((char *) hfp_connection->line_buffer); 1576 hfp_next_indicators_index(hfp_connection); 1577 break; 1578 case HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE: 1579 hfp_next_indicators_index(hfp_connection); 1580 if (hfp_connection->parser_item_index != 4) break; 1581 log_info("Parsed Enable indicators: %s\n", hfp_connection->line_buffer); 1582 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1583 hfp_connection->enable_status_update_for_ag_indicators = (uint8_t) value; 1584 break; 1585 case HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES: 1586 log_info("Parsed Support call hold: %s\n", hfp_connection->line_buffer); 1587 if (hfp_connection->line_size > 2 ) break; 1588 memcpy((char *)hfp_connection->remote_call_services[hfp_connection->remote_call_services_index].name, (char *)hfp_connection->line_buffer, HFP_CALL_SERVICE_SIZE-1); 1589 hfp_connection->remote_call_services[hfp_connection->remote_call_services_index].name[HFP_CALL_SERVICE_SIZE - 1] = 0; 1590 hfp_next_remote_call_services_index(hfp_connection); 1591 break; 1592 case HFP_CMD_LIST_GENERIC_STATUS_INDICATORS: 1593 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS: 1594 log_info("Parsed Generic status indicator: %s\n", hfp_connection->line_buffer); 1595 hfp_connection->generic_status_indicators[hfp_connection->parser_item_index].uuid = (uint16_t)btstack_atoi((char*)hfp_connection->line_buffer); 1596 hfp_next_indicators_index(hfp_connection); 1597 hfp_connection->generic_status_indicators_nr = hfp_connection->parser_item_index; 1598 break; 1599 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1600 // HF parses inital AG gen. ind. state 1601 log_info("Parsed List generic status indicator %s state: ", hfp_connection->line_buffer); 1602 hfp_connection->parser_item_index = hfp_parse_indicator_index(hfp_connection); 1603 break; 1604 case HFP_CMD_HF_INDICATOR_STATUS: 1605 hfp_connection->parser_indicator_index = hfp_parse_indicator_index(hfp_connection); 1606 log_info("Parsed HF indicator index %u", hfp_connection->parser_indicator_index); 1607 break; 1608 case HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE: 1609 // AG parses new gen. ind. state 1610 if (hfp_connection->ignore_value){ 1611 hfp_connection->ignore_value = 0; 1612 log_info("Parsed Enable AG indicator pos %u('%s') - unchanged (stays %u)\n", hfp_connection->parser_item_index, 1613 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, hfp_connection->ag_indicators[hfp_connection->parser_item_index].enabled); 1614 } 1615 else if (hfp_connection->ag_indicators[hfp_connection->parser_item_index].mandatory){ 1616 log_info("Parsed Enable AG indicator pos %u('%s') - ignore (mandatory)\n", 1617 hfp_connection->parser_item_index, hfp_connection->ag_indicators[hfp_connection->parser_item_index].name); 1618 } else { 1619 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1620 hfp_connection->ag_indicators[hfp_connection->parser_item_index].enabled = value; 1621 log_info("Parsed Enable AG indicator pos %u('%s'): %u\n", hfp_connection->parser_item_index, 1622 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, value); 1623 } 1624 hfp_next_indicators_index(hfp_connection); 1625 break; 1626 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1627 // indicators are indexed starting with 1 1628 hfp_connection->parser_item_index = hfp_parse_indicator_index(hfp_connection); 1629 log_info("Parsed status of the AG indicator %d, status ", hfp_connection->parser_item_index); 1630 break; 1631 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1632 hfp_connection->network_operator.mode = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1633 log_info("Parsed network operator mode: %d, ", hfp_connection->network_operator.mode); 1634 break; 1635 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1636 if (hfp_connection->line_buffer[0] == '3'){ 1637 log_info("Parsed Set network operator format : %s, ", hfp_connection->line_buffer); 1638 break; 1639 } 1640 // TODO emit ERROR, wrong format 1641 log_info("ERROR Set network operator format: index %s not supported\n", hfp_connection->line_buffer); 1642 break; 1643 case HFP_CMD_ERROR: 1644 break; 1645 case HFP_CMD_EXTENDED_AUDIO_GATEWAY_ERROR: 1646 hfp_connection->extended_audio_gateway_error = 1; 1647 hfp_connection->extended_audio_gateway_error_value = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1648 break; 1649 case HFP_CMD_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR: 1650 hfp_connection->enable_extended_audio_gateway_error_report = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1651 hfp_connection->ok_pending = 1; 1652 hfp_connection->extended_audio_gateway_error = 0; 1653 break; 1654 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1655 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1656 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1657 strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number)); 1658 hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0; 1659 break; 1660 case HFP_CMD_CALL_HOLD: 1661 hfp_connection->ag_call_hold_action = hfp_connection->line_buffer[0] - '0'; 1662 if (hfp_connection->line_buffer[1] != '\0'){ 1663 hfp_connection->call_index = btstack_atoi((char *)&hfp_connection->line_buffer[1]); 1664 } 1665 break; 1666 case HFP_CMD_RESPONSE_AND_HOLD_COMMAND: 1667 hfp_connection->ag_response_and_hold_action = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1668 break; 1669 case HFP_CMD_TRANSMIT_DTMF_CODES: 1670 hfp_connection->ag_dtmf_code = hfp_connection->line_buffer[0]; 1671 break; 1672 case HFP_CMD_ENABLE_CLIP: 1673 hfp_connection->clip_enabled = hfp_connection->line_buffer[0] != '0'; 1674 break; 1675 case HFP_CMD_ENABLE_CALL_WAITING_NOTIFICATION: 1676 hfp_connection->call_waiting_notification_enabled = hfp_connection->line_buffer[0] != '0'; 1677 break; 1678 case HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION: 1679 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1680 hfp_connection->ag_activate_voice_recognition_value = value; 1681 break; 1682 case HFP_CMD_AG_ACTIVATE_VOICE_RECOGNITION: 1683 switch(hfp_connection->parser_item_index){ 1684 case 0: 1685 hfp_connection->ag_vra_status = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1686 break; 1687 case 1: 1688 hfp_connection->ag_vra_state = (hfp_voice_recognition_state_t) btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1689 break; 1690 case 2: 1691 hfp_connection->ag_msg.text_id = 0; 1692 for (i = 0 ; i < 4; i++){ 1693 hfp_connection->ag_msg.text_id = (hfp_connection->ag_msg.text_id << 4) | nibble_for_char(hfp_connection->line_buffer[i]); 1694 } 1695 break; 1696 case 3: 1697 hfp_connection->ag_msg.text_operation = (hfp_text_operation_t) btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1698 break; 1699 case 4: 1700 hfp_connection->ag_msg.text_type = (hfp_text_type_t) btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1701 break; 1702 case 5: 1703 hfp_connection->ag_vra_msg_length = hfp_connection->line_size; 1704 break; 1705 default: 1706 break; 1707 } 1708 hfp_connection->parser_item_index++; 1709 break; 1710 default: 1711 break; 1712 } 1713 } 1714 1715 static void hfp_handle_start_sdp_client_query(void * context){ 1716 UNUSED(context); 1717 1718 btstack_linked_list_iterator_t it; 1719 btstack_linked_list_iterator_init(&it, &hfp_connections); 1720 while (btstack_linked_list_iterator_has_next(&it)){ 1721 hfp_connection_t * connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1722 1723 if (connection->state != HFP_W2_SEND_SDP_QUERY) continue; 1724 1725 connection->state = HFP_W4_SDP_QUERY_COMPLETE; 1726 hfp_sdp_query_context.local_role = connection->local_role; 1727 (void)memcpy(hfp_sdp_query_context.remote_address, connection->remote_addr, 6); 1728 sdp_client_query_rfcomm_channel_and_name_for_service_class_uuid(&handle_query_rfcomm_event, connection->remote_addr, connection->service_uuid); 1729 return; 1730 } 1731 } 1732 1733 uint8_t hfp_establish_service_level_connection(bd_addr_t bd_addr, uint16_t service_uuid, hfp_role_t local_role){ 1734 hfp_connection_t * connection = get_hfp_connection_context_for_bd_addr(bd_addr, local_role); 1735 if (connection){ 1736 return ERROR_CODE_COMMAND_DISALLOWED; 1737 } 1738 1739 connection = hfp_create_connection(bd_addr, local_role); 1740 if (!connection){ 1741 return BTSTACK_MEMORY_ALLOC_FAILED; 1742 } 1743 1744 connection->state = HFP_W2_SEND_SDP_QUERY; 1745 1746 bd_addr_copy(connection->remote_addr, bd_addr); 1747 connection->service_uuid = service_uuid; 1748 1749 hfp_sdp_query_request.callback = &hfp_handle_start_sdp_client_query; 1750 // ignore ERROR_CODE_COMMAND_DISALLOWED because in that case, we already have requested an SDP callback 1751 (void) sdp_client_register_query_callback(&hfp_sdp_query_request); 1752 return ERROR_CODE_SUCCESS; 1753 } 1754 1755 void hfp_trigger_release_service_level_connection(hfp_connection_t * hfp_connection){ 1756 // called internally, NULL check already performed 1757 btstack_assert(hfp_connection != NULL); 1758 1759 hfp_trigger_release_audio_connection(hfp_connection); 1760 if (hfp_connection->state < HFP_W4_RFCOMM_CONNECTED){ 1761 hfp_connection->state = HFP_IDLE; 1762 return; 1763 } 1764 1765 if (hfp_connection->state == HFP_W4_RFCOMM_CONNECTED){ 1766 hfp_connection->state = HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN; 1767 return; 1768 } 1769 hfp_connection->release_slc_connection = 1; 1770 if (hfp_connection->state < HFP_W4_SCO_CONNECTED){ 1771 hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM; 1772 return; 1773 } 1774 1775 if (hfp_connection->state < HFP_W4_SCO_DISCONNECTED){ 1776 hfp_connection->state = HFP_W2_DISCONNECT_SCO; 1777 hfp_connection->release_audio_connection = 1; 1778 return; 1779 } 1780 } 1781 1782 uint8_t hfp_trigger_release_audio_connection(hfp_connection_t * hfp_connection){ 1783 // called internally, NULL check already performed 1784 btstack_assert(hfp_connection != NULL); 1785 if (hfp_connection->state <= HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED){ 1786 return ERROR_CODE_COMMAND_DISALLOWED; 1787 } 1788 switch (hfp_connection->state) { 1789 case HFP_W2_CONNECT_SCO: 1790 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 1791 break; 1792 case HFP_W4_SCO_CONNECTED: 1793 case HFP_AUDIO_CONNECTION_ESTABLISHED: 1794 hfp_connection->release_audio_connection = 1; 1795 break; 1796 default: 1797 return ERROR_CODE_COMMAND_DISALLOWED; 1798 } 1799 return ERROR_CODE_SUCCESS; 1800 } 1801 1802 static const struct link_settings { 1803 const uint16_t max_latency; 1804 const uint8_t retransmission_effort; 1805 const uint16_t packet_types; 1806 const bool eSCO; 1807 const uint8_t codec; 1808 } hfp_link_settings [] = { 1809 { 0xffff, 0xff, SCO_PACKET_TYPES_HV1, false, HFP_CODEC_CVSD }, // HFP_LINK_SETTINGS_D0 1810 { 0xffff, 0xff, SCO_PACKET_TYPES_HV3, false, HFP_CODEC_CVSD }, // HFP_LINK_SETTINGS_D1 1811 { 0x0007, 0x01, SCO_PACKET_TYPES_EV3, true, HFP_CODEC_CVSD }, // HFP_LINK_SETTINGS_S1 1812 { 0x0007, 0x01, SCO_PACKET_TYPES_2EV3, true, HFP_CODEC_CVSD }, // HFP_LINK_SETTINGS_S2 1813 { 0x000a, 0x01, SCO_PACKET_TYPES_2EV3, true, HFP_CODEC_CVSD }, // HFP_LINK_SETTINGS_S3 1814 { 0x000c, 0x02, SCO_PACKET_TYPES_2EV3, true, HFP_CODEC_CVSD }, // HFP_LINK_SETTINGS_S4 1815 { 0x0008, 0x02, SCO_PACKET_TYPES_EV3, true, HFP_CODEC_MSBC }, // HFP_LINK_SETTINGS_T1 1816 { 0x000d, 0x02, SCO_PACKET_TYPES_2EV3, true, HFP_CODEC_MSBC } // HFP_LINK_SETTINGS_T2 1817 }; 1818 1819 void hfp_setup_synchronous_connection(hfp_connection_t * hfp_connection){ 1820 // all packet types, fixed bandwidth 1821 int setting = hfp_connection->link_setting; 1822 log_info("hfp_setup_synchronous_connection using setting nr %u", setting); 1823 hfp_sco_establishment_active = hfp_connection; 1824 uint16_t sco_voice_setting = hci_get_sco_voice_setting(); 1825 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 1826 #ifdef ENABLE_BCM_PCM_WBS 1827 sco_voice_setting = 0x0063; // Transparent data, 16-bit for BCM controllers 1828 #else 1829 sco_voice_setting = 0x0043; // Transparent data, 8-bit otherwise 1830 #endif 1831 } 1832 // get packet types - bits 6-9 are 'don't allow' 1833 uint16_t packet_types = hfp_link_settings[setting].packet_types ^ 0x03c0; 1834 hci_send_cmd(&hci_setup_synchronous_connection, hfp_connection->acl_handle, 8000, 8000, hfp_link_settings[setting].max_latency, 1835 sco_voice_setting, hfp_link_settings[setting].retransmission_effort, packet_types); 1836 } 1837 1838 void hfp_accept_synchronous_connection(hfp_connection_t * hfp_connection, bool incoming_eSCO){ 1839 1840 // remote supported feature eSCO is set if link type is eSCO 1841 // eSCO: S4 - max latency == transmission interval = 0x000c == 12 ms, 1842 uint16_t max_latency; 1843 uint8_t retransmission_effort; 1844 uint16_t packet_types; 1845 1846 if (incoming_eSCO && hci_extended_sco_link_supported() && hci_remote_esco_supported(hfp_connection->acl_handle)){ 1847 max_latency = 0x000c; 1848 retransmission_effort = 0x02; 1849 // eSCO: EV3 and 2-EV3 1850 packet_types = 0x0048; 1851 } else { 1852 max_latency = 0xffff; 1853 retransmission_effort = 0xff; 1854 // sco: HV1 and HV3 1855 packet_types = 0x005; 1856 } 1857 1858 // mSBC only allows for transparent data 1859 uint16_t sco_voice_setting = hci_get_sco_voice_setting(); 1860 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 1861 #ifdef ENABLE_BCM_PCM_WBS 1862 sco_voice_setting = 0x0063; // Transparent data, 16-bit for BCM controllers 1863 #else 1864 sco_voice_setting = 0x0043; // Transparent data, 8-bit otherwise 1865 #endif 1866 } 1867 1868 // filter packet types 1869 packet_types &= hfp_get_sco_packet_types(); 1870 1871 // bits 6-9 are 'don't allow' 1872 packet_types ^= 0x3c0; 1873 1874 log_info("HFP: sending hci_accept_connection_request, packet types 0x%04x, sco_voice_setting 0x%02x", packet_types, sco_voice_setting); 1875 hci_send_cmd(&hci_accept_synchronous_connection, hfp_connection->remote_addr, 8000, 8000, max_latency, 1876 sco_voice_setting, retransmission_effort, packet_types); 1877 } 1878 1879 #ifdef ENABLE_CC256X_ASSISTED_HFP 1880 void hfp_cc256x_prepare_for_sco(hfp_connection_t * hfp_connection){ 1881 hfp_connection->cc256x_send_write_codec_config = true; 1882 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 1883 hfp_connection->cc256x_send_wbs_associate = true; 1884 } 1885 } 1886 1887 void hfp_cc256x_write_codec_config(hfp_connection_t * hfp_connection){ 1888 uint32_t sample_rate_hz; 1889 uint16_t clock_rate_khz; 1890 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 1891 clock_rate_khz = 512; 1892 sample_rate_hz = 16000; 1893 } else { 1894 clock_rate_khz = 256; 1895 sample_rate_hz = 8000; 1896 } 1897 uint8_t clock_direction = 0; // master 1898 uint16_t frame_sync_duty_cycle = 0; // i2s with 50% 1899 uint8_t frame_sync_edge = 1; // rising edge 1900 uint8_t frame_sync_polarity = 0; // active high 1901 uint8_t reserved = 0; 1902 uint16_t size = 16; 1903 uint16_t chan_1_offset = 1; 1904 uint16_t chan_2_offset = chan_1_offset + size; 1905 uint8_t out_edge = 1; // rising 1906 uint8_t in_edge = 0; // falling 1907 hci_send_cmd(&hci_ti_write_codec_config, clock_rate_khz, clock_direction, sample_rate_hz, frame_sync_duty_cycle, 1908 frame_sync_edge, frame_sync_polarity, reserved, 1909 size, chan_1_offset, out_edge, size, chan_1_offset, in_edge, reserved, 1910 size, chan_2_offset, out_edge, size, chan_2_offset, in_edge, reserved); 1911 } 1912 #endif 1913 1914 #ifdef ENABLE_BCM_PCM_WBS 1915 void hfp_bcm_prepare_for_sco(hfp_connection_t * hfp_connection){ 1916 hfp_connection->bcm_send_write_i2spcm_interface_param = true; 1917 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 1918 hfp_connection->bcm_send_enable_wbs = true; 1919 } 1920 } 1921 void hfp_bcm_write_i2spcm_interface_param(hfp_connection_t * hfp_connection){ 1922 uint8_t sample_rate = (hfp_connection->negotiated_codec == HFP_CODEC_MSBC) ? 1 : 0; 1923 // i2s enable, master, 8/16 kHz, 512 kHz 1924 hci_send_cmd(&hci_bcm_write_i2spcm_interface_paramhci_bcm_write_i2spcm_interface_param, 1, 1, sample_rate, 2); 1925 } 1926 #endif 1927 1928 void hfp_set_hf_callback(btstack_packet_handler_t callback){ 1929 hfp_hf_callback = callback; 1930 } 1931 1932 void hfp_set_ag_callback(btstack_packet_handler_t callback){ 1933 hfp_ag_callback = callback; 1934 } 1935 1936 void hfp_set_ag_rfcomm_packet_handler(btstack_packet_handler_t handler){ 1937 hfp_ag_rfcomm_packet_handler = handler; 1938 } 1939 1940 void hfp_set_hf_rfcomm_packet_handler(btstack_packet_handler_t handler){ 1941 hfp_hf_rfcomm_packet_handler = handler; 1942 } 1943 1944 void hfp_init(void){ 1945 hfp_allowed_sco_packet_types = SCO_PACKET_TYPES_ALL; 1946 } 1947 1948 void hfp_deinit(void){ 1949 hfp_allowed_sco_packet_types = 0; 1950 hfp_connections = NULL; 1951 hfp_hf_callback = NULL; 1952 hfp_ag_callback = NULL; 1953 hfp_hf_rfcomm_packet_handler = NULL; 1954 hfp_ag_rfcomm_packet_handler = NULL; 1955 hfp_sco_establishment_active = NULL; 1956 (void) memset(&hfp_sdp_query_context, 0, sizeof(hfp_sdp_query_context_t)); 1957 (void) memset(&hfp_sdp_query_request, 0, sizeof(btstack_context_callback_registration_t)); 1958 } 1959 1960 void hfp_set_sco_packet_types(uint16_t packet_types){ 1961 hfp_allowed_sco_packet_types = packet_types; 1962 } 1963 1964 uint16_t hfp_get_sco_packet_types(void){ 1965 return hfp_allowed_sco_packet_types; 1966 } 1967 1968 hfp_link_settings_t hfp_next_link_setting(hfp_link_settings_t current_setting, bool local_eSCO_supported, bool remote_eSCO_supported, bool eSCO_S4_supported, uint8_t negotiated_codec){ 1969 int8_t setting = (int8_t) current_setting; 1970 bool can_use_eSCO = local_eSCO_supported && remote_eSCO_supported; 1971 while (setting > 0){ 1972 setting--; 1973 // skip if eSCO required but not available 1974 if (hfp_link_settings[setting].eSCO && !can_use_eSCO) continue; 1975 // skip if S4 but not supported 1976 if ((setting == (int8_t) HFP_LINK_SETTINGS_S4) && !eSCO_S4_supported) continue; 1977 // skip wrong codec 1978 if ( hfp_link_settings[setting].codec != negotiated_codec) continue; 1979 // skip disabled packet types 1980 uint16_t required_packet_types = hfp_link_settings[setting].packet_types; 1981 uint16_t allowed_packet_types = hfp_allowed_sco_packet_types; 1982 if ((required_packet_types & allowed_packet_types) == 0) continue; 1983 1984 // found matching setting 1985 return (hfp_link_settings_t) setting; 1986 } 1987 return HFP_LINK_SETTINGS_NONE; 1988 } 1989 1990 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){ 1991 bool local_eSCO_supported = hci_extended_sco_link_supported(); 1992 bool remote_eSCO_supported = hci_remote_esco_supported(hfp_connection->acl_handle); 1993 uint8_t negotiated_codec = hfp_connection->negotiated_codec; 1994 return hfp_next_link_setting(current_setting, local_eSCO_supported, remote_eSCO_supported, eSCO_S4_supported, negotiated_codec); 1995 } 1996 1997 void hfp_init_link_settings(hfp_connection_t * hfp_connection, uint8_t eSCO_S4_supported){ 1998 // get highest possible link setting 1999 hfp_connection->link_setting = hfp_next_link_setting_for_connection(HFP_LINK_SETTINGS_NONE, hfp_connection, eSCO_S4_supported); 2000 log_info("hfp_init_link_settings: %u", hfp_connection->link_setting); 2001 } 2002 2003 #define HFP_HF_RX_DEBUG_PRINT_LINE 80 2004 2005 void hfp_log_rfcomm_message(const char * tag, uint8_t * packet, uint16_t size){ 2006 #ifdef ENABLE_LOG_INFO 2007 // encode \n\r 2008 char printable[HFP_HF_RX_DEBUG_PRINT_LINE+2]; 2009 int i = 0; 2010 int pos; 2011 for (pos=0 ; (pos < size) && (i < (HFP_HF_RX_DEBUG_PRINT_LINE - 3)) ; pos++){ 2012 switch (packet[pos]){ 2013 case '\n': 2014 printable[i++] = '\\'; 2015 printable[i++] = 'n'; 2016 break; 2017 case '\r': 2018 printable[i++] = '\\'; 2019 printable[i++] = 'r'; 2020 break; 2021 default: 2022 printable[i++] = packet[pos]; 2023 break; 2024 } 2025 } 2026 printable[i] = 0; 2027 log_info("%s: '%s'", tag, printable); 2028 #endif 2029 } 2030