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 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_enabled(hfp_connection_t * hfp_connection, uint8_t status){ 357 btstack_assert(hfp_connection != NULL); 358 359 uint8_t event[7]; 360 event[0] = HCI_EVENT_HFP_META; 361 event[1] = sizeof(event) - 2; 362 event[2] = HFP_SUBEVENT_VOICE_RECOGNITION_ACTIVATED; 363 364 little_endian_store_16(event, 3, hfp_connection->acl_handle); 365 event[5] = status; // 0:success 366 event[6] = hfp_connection->enhanced_voice_recognition_enabled ? 1 : 0; 367 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 368 } 369 370 void hfp_emit_voice_recognition_disabled(hfp_connection_t * hfp_connection, uint8_t status){ 371 btstack_assert(hfp_connection != NULL); 372 373 uint8_t event[6]; 374 event[0] = HCI_EVENT_HFP_META; 375 event[1] = sizeof(event) - 2; 376 event[2] = HFP_SUBEVENT_VOICE_RECOGNITION_DEACTIVATED; 377 378 little_endian_store_16(event, 3, hfp_connection->acl_handle); 379 event[5] = status; // 0:success 380 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 381 } 382 383 void hfp_emit_enhanced_voice_recognition_hf_ready_for_audio_event(hfp_connection_t * hfp_connection, uint8_t status){ 384 hci_con_handle_t acl_handle = (hfp_connection != NULL) ? hfp_connection->acl_handle : HCI_CON_HANDLE_INVALID; 385 386 uint8_t event[6]; 387 event[0] = HCI_EVENT_HFP_META; 388 event[1] = sizeof(event) - 2; 389 event[2] = HFP_SUBEVENT_ENHANCED_VOICE_RECOGNITION_HF_READY_FOR_AUDIO; 390 little_endian_store_16(event, 3, acl_handle); 391 event[5] = status; 392 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 393 } 394 395 void hfp_emit_enhanced_voice_recognition_state_event(hfp_connection_t * hfp_connection, uint8_t status){ 396 hci_con_handle_t acl_handle = (hfp_connection != NULL) ? hfp_connection->acl_handle : HCI_CON_HANDLE_INVALID; 397 398 uint8_t event[6]; 399 event[0] = HCI_EVENT_HFP_META; 400 event[1] = sizeof(event) - 2; 401 switch (hfp_connection->ag_vra_state){ 402 case HFP_VOICE_RECOGNITION_STATE_AG_READY_TO_ACCEPT_AUDIO_INPUT: 403 event[2] = HFP_SUBEVENT_ENHANCED_VOICE_RECOGNITION_AG_READY_TO_ACCEPT_AUDIO_INPUT; 404 break; 405 case HFP_VOICE_RECOGNITION_STATE_AG_IS_STARTING_SOUND: 406 event[2] = HFP_SUBEVENT_ENHANCED_VOICE_RECOGNITION_AG_IS_STARTING_SOUND; 407 break; 408 case HFP_VOICE_RECOGNITION_STATE_AG_IS_PROCESSING_AUDIO_INPUT: 409 event[2] = HFP_SUBEVENT_ENHANCED_VOICE_RECOGNITION_AG_IS_PROCESSING_AUDIO_INPUT; 410 break; 411 default: 412 btstack_unreachable(); 413 break; 414 } 415 416 little_endian_store_16(event, 3, acl_handle); 417 event[5] = status; 418 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 419 } 420 421 void hfp_emit_slc_connection_event(hfp_connection_t * hfp_connection, uint8_t status, hci_con_handle_t con_handle, bd_addr_t addr){ 422 btstack_assert(hfp_connection != NULL); 423 uint8_t event[12]; 424 int pos = 0; 425 event[pos++] = HCI_EVENT_HFP_META; 426 event[pos++] = sizeof(event) - 2; 427 event[pos++] = HFP_SUBEVENT_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 428 little_endian_store_16(event, pos, con_handle); 429 pos += 2; 430 event[pos++] = status; // status 0 == OK 431 reverse_bd_addr(addr,&event[pos]); 432 pos += 6; 433 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 434 } 435 436 static void hfp_emit_audio_connection_released(hfp_connection_t * hfp_connection, hci_con_handle_t sco_handle){ 437 btstack_assert(hfp_connection != NULL); 438 uint8_t event[7]; 439 int pos = 0; 440 event[pos++] = HCI_EVENT_HFP_META; 441 event[pos++] = sizeof(event) - 2; 442 event[pos++] = HFP_SUBEVENT_AUDIO_CONNECTION_RELEASED; 443 little_endian_store_16(event, pos, hfp_connection->acl_handle); 444 pos += 2; 445 little_endian_store_16(event, pos, sco_handle); 446 pos += 2; 447 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 448 } 449 450 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){ 451 btstack_assert(hfp_connection != NULL); 452 uint8_t event[15]; 453 int pos = 0; 454 event[pos++] = HCI_EVENT_HFP_META; 455 event[pos++] = sizeof(event) - 2; 456 event[pos++] = HFP_SUBEVENT_AUDIO_CONNECTION_ESTABLISHED; 457 little_endian_store_16(event, pos, hfp_connection->acl_handle); 458 pos += 2; 459 event[pos++] = status; // status 0 == OK 460 little_endian_store_16(event, pos, sco_handle); 461 pos += 2; 462 reverse_bd_addr(addr,&event[pos]); 463 pos += 6; 464 event[pos++] = negotiated_codec; 465 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 466 } 467 468 void hfp_emit_string_event(hfp_connection_t * hfp_connection, uint8_t event_subtype, const char * value){ 469 btstack_assert(hfp_connection != NULL); 470 #ifdef ENABLE_HFP_AT_MESSAGES 471 uint8_t event[256]; 472 #else 473 uint8_t event[40]; 474 #endif 475 event[0] = HCI_EVENT_HFP_META; 476 event[1] = sizeof(event) - 2; 477 event[2] = event_subtype; 478 little_endian_store_16(event, 3, hfp_connection->acl_handle); 479 uint16_t size = btstack_min(strlen(value), sizeof(event) - 6); 480 strncpy((char*)&event[5], value, size); 481 event[5 + size] = 0; 482 hfp_emit_event_for_context(hfp_connection, event, sizeof(event)); 483 } 484 485 btstack_linked_list_t * hfp_get_connections(void){ 486 return (btstack_linked_list_t *) &hfp_connections; 487 } 488 489 hfp_connection_t * get_hfp_connection_context_for_rfcomm_cid(uint16_t cid){ 490 btstack_linked_list_iterator_t it; 491 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 492 while (btstack_linked_list_iterator_has_next(&it)){ 493 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 494 if (hfp_connection->rfcomm_cid == cid){ 495 return hfp_connection; 496 } 497 } 498 return NULL; 499 } 500 501 hfp_connection_t * get_hfp_connection_context_for_bd_addr(bd_addr_t bd_addr, hfp_role_t hfp_role){ 502 btstack_linked_list_iterator_t it; 503 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 504 while (btstack_linked_list_iterator_has_next(&it)){ 505 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 506 if ((memcmp(hfp_connection->remote_addr, bd_addr, 6) == 0) && (hfp_connection->local_role == hfp_role)) { 507 return hfp_connection; 508 } 509 } 510 return NULL; 511 } 512 513 hfp_connection_t * get_hfp_connection_context_for_sco_handle(uint16_t handle, hfp_role_t hfp_role){ 514 btstack_linked_list_iterator_t it; 515 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 516 while (btstack_linked_list_iterator_has_next(&it)){ 517 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 518 if ((hfp_connection->sco_handle == handle) && (hfp_connection->local_role == hfp_role)){ 519 return hfp_connection; 520 } 521 } 522 return NULL; 523 } 524 525 hfp_connection_t * get_hfp_connection_context_for_acl_handle(uint16_t handle, hfp_role_t hfp_role){ 526 btstack_linked_list_iterator_t it; 527 btstack_linked_list_iterator_init(&it, hfp_get_connections()); 528 while (btstack_linked_list_iterator_has_next(&it)){ 529 hfp_connection_t * hfp_connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 530 if ((hfp_connection->acl_handle == handle) && (hfp_connection->local_role == hfp_role)){ 531 return hfp_connection; 532 } 533 } 534 return NULL; 535 } 536 537 538 static void hfp_reset_voice_recognition(hfp_connection_t * hfp_connection){ 539 btstack_assert(hfp_connection != NULL); 540 hfp_voice_recognition_activation_status_t current_vra_state = hfp_connection->vra_state; 541 hfp_connection->vra_state = HFP_VRA_VOICE_RECOGNITION_OFF; 542 543 if (current_vra_state != HFP_VRA_VOICE_RECOGNITION_OFF){ 544 hfp_emit_voice_recognition_disabled(hfp_connection, ERROR_CODE_SUCCESS); 545 } else if (hfp_connection->vra_state_requested != HFP_VRA_VOICE_RECOGNITION_OFF){ 546 hfp_emit_voice_recognition_disabled(hfp_connection, ERROR_CODE_SUCCESS); 547 } 548 549 hfp_connection->vra_state_requested = HFP_VRA_VOICE_RECOGNITION_OFF; 550 hfp_connection->activate_voice_recognition = false; 551 hfp_connection->deactivate_voice_recognition = false; 552 hfp_connection->enhanced_voice_recognition_enabled = false; 553 hfp_connection->ag_vra_status = 0; 554 hfp_connection->ag_vra_state = HFP_VOICE_RECOGNITION_STATE_AG_READY; 555 } 556 557 void hfp_reset_context_flags(hfp_connection_t * hfp_connection){ 558 if (!hfp_connection) return; 559 hfp_connection->ok_pending = 0; 560 hfp_connection->send_error = 0; 561 562 hfp_connection->found_equal_sign = false; 563 564 hfp_connection->change_status_update_for_individual_ag_indicators = 0; 565 hfp_connection->operator_name_changed = 0; 566 567 hfp_connection->enable_extended_audio_gateway_error_report = 0; 568 hfp_connection->extended_audio_gateway_error = 0; 569 570 // establish codecs hfp_connection 571 hfp_connection->suggested_codec = 0; 572 hfp_connection->negotiated_codec = 0; 573 hfp_connection->codec_confirmed = 0; 574 575 hfp_connection->establish_audio_connection = 0; 576 hfp_connection->call_waiting_notification_enabled = 0; 577 hfp_connection->command = HFP_CMD_NONE; 578 hfp_connection->enable_status_update_for_ag_indicators = 0xFF; 579 hfp_reset_voice_recognition(hfp_connection); 580 } 581 582 static hfp_connection_t * create_hfp_connection_context(void){ 583 hfp_connection_t * hfp_connection = btstack_memory_hfp_connection_get(); 584 if (!hfp_connection) return NULL; 585 586 hfp_connection->state = HFP_IDLE; 587 hfp_connection->call_state = HFP_CALL_IDLE; 588 hfp_connection->codecs_state = HFP_CODECS_IDLE; 589 590 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 591 592 hfp_connection->acl_handle = HCI_CON_HANDLE_INVALID; 593 hfp_connection->sco_handle = HCI_CON_HANDLE_INVALID; 594 595 hfp_reset_context_flags(hfp_connection); 596 597 btstack_linked_list_add(&hfp_connections, (btstack_linked_item_t*)hfp_connection); 598 return hfp_connection; 599 } 600 601 void hfp_finalize_connection_context(hfp_connection_t * hfp_connection){ 602 btstack_linked_list_remove(&hfp_connections, (btstack_linked_item_t*) hfp_connection); 603 btstack_memory_hfp_connection_free(hfp_connection); 604 } 605 606 static hfp_connection_t * hfp_create_connection(bd_addr_t bd_addr, hfp_role_t local_role){ 607 hfp_connection_t * hfp_connection = get_hfp_connection_context_for_bd_addr(bd_addr, local_role); 608 if (hfp_connection) return hfp_connection; 609 hfp_connection = create_hfp_connection_context(); 610 (void)memcpy(hfp_connection->remote_addr, bd_addr, 6); 611 hfp_connection->local_role = local_role; 612 log_info("Create HFP context %p: role %u, addr %s", hfp_connection, local_role, bd_addr_to_str(bd_addr)); 613 614 return hfp_connection; 615 } 616 617 /* @param network. 618 * 0 == no ability to reject a call. 619 * 1 == ability to reject a call. 620 */ 621 622 /* @param suported_features 623 * HF bit 0: EC and/or NR function (yes/no, 1 = yes, 0 = no) 624 * HF bit 1: Call waiting or three-way calling(yes/no, 1 = yes, 0 = no) 625 * HF bit 2: CLI presentation capability (yes/no, 1 = yes, 0 = no) 626 * HF bit 3: Voice recognition activation (yes/no, 1= yes, 0 = no) 627 * HF bit 4: Remote volume control (yes/no, 1 = yes, 0 = no) 628 * HF bit 5: Wide band speech (yes/no, 1 = yes, 0 = no) 629 */ 630 /* Bit position: 631 * AG bit 0: Three-way calling (yes/no, 1 = yes, 0 = no) 632 * AG bit 1: EC and/or NR function (yes/no, 1 = yes, 0 = no) 633 * AG bit 2: Voice recognition function (yes/no, 1 = yes, 0 = no) 634 * AG bit 3: In-band ring tone capability (yes/no, 1 = yes, 0 = no) 635 * AG bit 4: Attach a phone number to a voice tag (yes/no, 1 = yes, 0 = no) 636 * AG bit 5: Wide band speech (yes/no, 1 = yes, 0 = no) 637 */ 638 639 void hfp_create_sdp_record(uint8_t * service, uint32_t service_record_handle, uint16_t service_uuid, int rfcomm_channel_nr, const char * name){ 640 uint8_t* attribute; 641 de_create_sequence(service); 642 643 // 0x0000 "Service Record Handle" 644 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_RECORD_HANDLE); 645 de_add_number(service, DE_UINT, DE_SIZE_32, service_record_handle); 646 647 // 0x0001 "Service Class ID List" 648 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST); 649 attribute = de_push_sequence(service); 650 { 651 // "UUID for Service" 652 de_add_number(attribute, DE_UUID, DE_SIZE_16, service_uuid); 653 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_GENERIC_AUDIO); 654 } 655 de_pop_sequence(service, attribute); 656 657 // 0x0004 "Protocol Descriptor List" 658 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST); 659 attribute = de_push_sequence(service); 660 { 661 uint8_t* l2cpProtocol = de_push_sequence(attribute); 662 { 663 de_add_number(l2cpProtocol, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_L2CAP); 664 } 665 de_pop_sequence(attribute, l2cpProtocol); 666 667 uint8_t* rfcomm = de_push_sequence(attribute); 668 { 669 de_add_number(rfcomm, DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_RFCOMM); // rfcomm_service 670 de_add_number(rfcomm, DE_UINT, DE_SIZE_8, rfcomm_channel_nr); // rfcomm channel 671 } 672 de_pop_sequence(attribute, rfcomm); 673 } 674 de_pop_sequence(service, attribute); 675 676 677 // 0x0005 "Public Browse Group" 678 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BROWSE_GROUP_LIST); // public browse group 679 attribute = de_push_sequence(service); 680 { 681 de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PUBLIC_BROWSE_ROOT); 682 } 683 de_pop_sequence(service, attribute); 684 685 // 0x0009 "Bluetooth Profile Descriptor List" 686 de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BLUETOOTH_PROFILE_DESCRIPTOR_LIST); 687 attribute = de_push_sequence(service); 688 { 689 uint8_t *sppProfile = de_push_sequence(attribute); 690 { 691 de_add_number(sppProfile, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_HANDSFREE); 692 de_add_number(sppProfile, DE_UINT, DE_SIZE_16, 0x0108); // Verision 1.8 693 } 694 de_pop_sequence(attribute, sppProfile); 695 } 696 de_pop_sequence(service, attribute); 697 698 // 0x0100 "Service Name" 699 de_add_number(service, DE_UINT, DE_SIZE_16, 0x0100); 700 de_add_data(service, DE_STRING, strlen(name), (uint8_t *) name); 701 } 702 703 static void handle_query_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 704 UNUSED(packet_type); // ok: handling own sdp events 705 UNUSED(channel); // ok: no channel 706 UNUSED(size); // ok: handling own sdp events 707 708 hfp_connection_t * hfp_connection = get_hfp_connection_context_for_bd_addr(hfp_sdp_query_context.remote_address, hfp_sdp_query_context.local_role); 709 if (hfp_connection == NULL) { 710 log_info("connection with %s and local role %d not found", hfp_sdp_query_context.remote_address, hfp_sdp_query_context.local_role); 711 return; 712 } 713 714 switch (hci_event_packet_get_type(packet)){ 715 case SDP_EVENT_QUERY_RFCOMM_SERVICE: 716 hfp_connection->rfcomm_channel_nr = sdp_event_query_rfcomm_service_get_rfcomm_channel(packet); 717 break; 718 case SDP_EVENT_QUERY_COMPLETE: 719 if (hfp_connection->rfcomm_channel_nr > 0){ 720 hfp_connection->state = HFP_W4_RFCOMM_CONNECTED; 721 btstack_packet_handler_t packet_handler; 722 switch (hfp_connection->local_role){ 723 case HFP_ROLE_AG: 724 packet_handler = hfp_ag_rfcomm_packet_handler; 725 break; 726 case HFP_ROLE_HF: 727 packet_handler = hfp_hf_rfcomm_packet_handler; 728 break; 729 default: 730 btstack_assert(false); 731 return; 732 } 733 734 rfcomm_create_channel(packet_handler, hfp_connection->remote_addr, hfp_connection->rfcomm_channel_nr, NULL); 735 736 } else { 737 hfp_connection->state = HFP_IDLE; 738 uint8_t status = sdp_event_query_complete_get_status(packet); 739 if (status == ERROR_CODE_SUCCESS){ 740 // report service not found 741 status = SDP_SERVICE_NOT_FOUND; 742 } 743 hfp_emit_slc_connection_event(hfp_connection, status, HCI_CON_HANDLE_INVALID, hfp_connection->remote_addr); 744 log_info("rfcomm service not found, status 0x%02x", status); 745 } 746 747 // register the SDP Query request to check if there is another connection waiting for the query 748 // ignore ERROR_CODE_COMMAND_DISALLOWED because in that case, we already have requested an SDP callback 749 (void) sdp_client_register_query_callback(&hfp_sdp_query_request); 750 break; 751 default: 752 break; 753 } 754 } 755 756 // returns 0 if unexpected error or no other link options remained, otherwise 1 757 static int hfp_handle_failed_sco_connection(uint8_t status){ 758 759 if (!hfp_sco_establishment_active){ 760 log_info("(e)SCO Connection failed but not started by us"); 761 return 0; 762 } 763 764 log_info("(e)SCO Connection failed 0x%02x", status); 765 switch (status){ 766 case ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE: 767 case ERROR_CODE_UNSPECIFIED_ERROR: 768 case ERROR_CODE_CONNECTION_REJECTED_DUE_TO_LIMITED_RESOURCES: 769 break; 770 default: 771 return 0; 772 } 773 774 // note: eSCO_S4 supported flag not available, but it's only relevant for highest CVSD link setting (and the current failed) 775 hfp_link_settings_t next_setting = hfp_next_link_setting_for_connection(hfp_sco_establishment_active->link_setting, hfp_sco_establishment_active, false); 776 777 // handle no valid setting found 778 if (next_setting == HFP_LINK_SETTINGS_NONE) { 779 if (hfp_sco_establishment_active->negotiated_codec == HFP_CODEC_MSBC){ 780 log_info("T2/T1 failed, fallback to CVSD - D1"); 781 hfp_sco_establishment_active->negotiated_codec = HFP_CODEC_CVSD; 782 hfp_sco_establishment_active->sco_for_msbc_failed = 1; 783 hfp_sco_establishment_active->ag_send_common_codec = true; 784 hfp_sco_establishment_active->link_setting = HFP_LINK_SETTINGS_D1; 785 } else { 786 // no other options 787 return 0; 788 } 789 } 790 791 log_info("e)SCO Connection: try new link_setting %d", next_setting); 792 hfp_sco_establishment_active->establish_audio_connection = 1; 793 hfp_sco_establishment_active->link_setting = next_setting; 794 hfp_sco_establishment_active = NULL; 795 return 1; 796 } 797 798 void hfp_handle_hci_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size, hfp_role_t local_role){ 799 UNUSED(packet_type); 800 UNUSED(channel); // ok: no channel 801 UNUSED(size); 802 803 bd_addr_t event_addr; 804 hci_con_handle_t handle; 805 hfp_connection_t * hfp_connection = NULL; 806 uint8_t status; 807 808 log_debug("HFP HCI event handler type %u, event type %x, size %u", packet_type, hci_event_packet_get_type(packet), size); 809 810 switch (hci_event_packet_get_type(packet)) { 811 812 case HCI_EVENT_CONNECTION_REQUEST: 813 switch(hci_event_connection_request_get_link_type(packet)){ 814 case 0: // SCO 815 case 2: // eSCO 816 hci_event_connection_request_get_bd_addr(packet, event_addr); 817 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 818 if (!hfp_connection) break; 819 if (hci_event_connection_request_get_link_type(packet) == 2){ 820 hfp_connection->accept_sco = 2; 821 } else { 822 hfp_connection->accept_sco = 1; 823 } 824 #ifdef ENABLE_CC256X_ASSISTED_HFP 825 hfp_cc256x_prepare_for_sco(hfp_connection); 826 #endif 827 #ifdef ENABLE_BCM_PCM_WBS 828 hfp_bcm_prepare_for_sco(hfp_connection); 829 #endif 830 #ifdef ENABLE_RTK_PCM_WBS 831 hfp_connection->rtk_send_sco_config = true; 832 #endif 833 log_info("accept sco %u\n", hfp_connection->accept_sco); 834 hfp_sco_establishment_active = hfp_connection; 835 break; 836 default: 837 break; 838 } 839 break; 840 841 case HCI_EVENT_COMMAND_STATUS: 842 if (hci_event_command_status_get_command_opcode(packet) == hci_setup_synchronous_connection.opcode) { 843 if (hfp_sco_establishment_active == NULL) break; 844 status = hci_event_command_status_get_status(packet); 845 if (status == ERROR_CODE_SUCCESS) break; 846 847 hfp_connection = hfp_sco_establishment_active; 848 if (hfp_handle_failed_sco_connection(status)) break; 849 hfp_connection->establish_audio_connection = 0; 850 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 851 hfp_emit_sco_event(hfp_connection, status, 0, hfp_connection->remote_addr, hfp_connection->negotiated_codec); 852 } 853 break; 854 855 case HCI_EVENT_SYNCHRONOUS_CONNECTION_COMPLETE:{ 856 if (hfp_sco_establishment_active == NULL) break; 857 hci_event_synchronous_connection_complete_get_bd_addr(packet, event_addr); 858 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 859 if (!hfp_connection) { 860 log_error("HFP: connection does not exist for remote with addr %s.", bd_addr_to_str(event_addr)); 861 return; 862 } 863 864 status = hci_event_synchronous_connection_complete_get_status(packet); 865 if (status != ERROR_CODE_SUCCESS){ 866 hfp_connection->accept_sco = 0; 867 if (hfp_handle_failed_sco_connection(status)) break; 868 869 hfp_connection->establish_audio_connection = 0; 870 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 871 hfp_emit_sco_event(hfp_connection, status, 0, event_addr, hfp_connection->negotiated_codec); 872 break; 873 } 874 875 uint16_t sco_handle = hci_event_synchronous_connection_complete_get_handle(packet); 876 uint8_t link_type = hci_event_synchronous_connection_complete_get_link_type(packet); 877 uint8_t transmission_interval = hci_event_synchronous_connection_complete_get_transmission_interval(packet); // measured in slots 878 uint8_t retransmission_interval = hci_event_synchronous_connection_complete_get_retransmission_interval(packet);// measured in slots 879 uint16_t rx_packet_length = hci_event_synchronous_connection_complete_get_rx_packet_length(packet); // measured in bytes 880 uint16_t tx_packet_length = hci_event_synchronous_connection_complete_get_tx_packet_length(packet); // measured in bytes 881 882 switch (link_type){ 883 case 0x00: 884 log_info("SCO Connection established."); 885 if (transmission_interval != 0) log_error("SCO Connection: transmission_interval not zero: %d.", transmission_interval); 886 if (retransmission_interval != 0) log_error("SCO Connection: retransmission_interval not zero: %d.", retransmission_interval); 887 if (rx_packet_length != 0) log_error("SCO Connection: rx_packet_length not zero: %d.", rx_packet_length); 888 if (tx_packet_length != 0) log_error("SCO Connection: tx_packet_length not zero: %d.", tx_packet_length); 889 break; 890 case 0x02: 891 log_info("eSCO Connection established. \n"); 892 break; 893 default: 894 log_error("(e)SCO reserved link_type 0x%2x", link_type); 895 break; 896 } 897 898 log_info("sco_handle 0x%2x, address %s, transmission_interval %u slots, retransmission_interval %u slots, " 899 " rx_packet_length %u bytes, tx_packet_length %u bytes, air_mode 0x%2x (0x02 == CVSD)\n", sco_handle, 900 bd_addr_to_str(event_addr), transmission_interval, retransmission_interval, rx_packet_length, tx_packet_length, 901 hci_event_synchronous_connection_complete_get_air_mode(packet)); 902 903 if (hfp_connection->state == HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN){ 904 log_info("SCO about to disconnect: HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN"); 905 hfp_connection->state = HFP_W2_DISCONNECT_SCO; 906 break; 907 } 908 hfp_connection->sco_handle = sco_handle; 909 hfp_connection->establish_audio_connection = 0; 910 911 hfp_connection->state = HFP_AUDIO_CONNECTION_ESTABLISHED; 912 913 switch (hfp_connection->vra_state){ 914 case HFP_VRA_VOICE_RECOGNITION_ACTIVATED: 915 hfp_connection->ag_audio_connection_opened_before_vra = false; 916 break; 917 default: 918 hfp_connection->ag_audio_connection_opened_before_vra = true; 919 break; 920 } 921 hfp_emit_sco_event(hfp_connection, status, sco_handle, event_addr, hfp_connection->negotiated_codec); 922 break; 923 } 924 925 case HCI_EVENT_DISCONNECTION_COMPLETE: 926 handle = little_endian_read_16(packet,3); 927 hfp_connection = get_hfp_connection_context_for_sco_handle(handle, local_role); 928 929 if (!hfp_connection) break; 930 931 #ifdef ENABLE_CC256X_ASSISTED_HFP 932 hfp_connection->cc256x_send_wbs_disassociate = true; 933 #endif 934 #ifdef ENABLE_BCM_PCM_WBS 935 hfp_connection->bcm_send_disable_wbs = true; 936 #endif 937 if (hfp_connection->sco_handle == handle){ 938 hfp_connection->sco_handle = HCI_CON_HANDLE_INVALID; 939 hfp_connection->release_audio_connection = 0; 940 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 941 hfp_emit_audio_connection_released(hfp_connection, handle); 942 943 hfp_connection->ag_audio_connection_opened_before_vra = false; 944 945 if (hfp_connection->acl_handle == HCI_CON_HANDLE_INVALID){ 946 hfp_reset_voice_recognition(hfp_connection); 947 hfp_emit_event(hfp_connection, HFP_SUBEVENT_SERVICE_LEVEL_CONNECTION_RELEASED, 0); 948 hfp_finalize_connection_context(hfp_connection); 949 break; 950 } else if (hfp_connection->release_slc_connection == 1){ 951 hfp_connection->release_slc_connection = 0; 952 hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM; 953 rfcomm_disconnect(hfp_connection->acl_handle); 954 } 955 } 956 957 if (hfp_connection->state == HFP_W4_SCO_DISCONNECTED_TO_SHUTDOWN){ 958 // RFCOMM already closed -> remote power off 959 #if defined(ENABLE_CC256X_ASSISTED_HFP) || defined (ENABLE_BCM_PCM_WBS) 960 hfp_connection->state = HFP_W4_WBS_SHUTDOWN; 961 #else 962 hfp_finalize_connection_context(hfp_connection); 963 #endif 964 break; 965 } 966 break; 967 968 default: 969 break; 970 } 971 } 972 973 974 void hfp_handle_rfcomm_event(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size, hfp_role_t local_role){ 975 UNUSED(packet_type); 976 UNUSED(channel); // ok: no channel 977 UNUSED(size); 978 979 bd_addr_t event_addr; 980 uint16_t rfcomm_cid; 981 hfp_connection_t * hfp_connection = NULL; 982 uint8_t status; 983 984 log_debug("HFP packet_handler type %u, event type %x, size %u", packet_type, hci_event_packet_get_type(packet), size); 985 986 switch (hci_event_packet_get_type(packet)) { 987 988 case RFCOMM_EVENT_INCOMING_CONNECTION: 989 // data: event (8), len(8), address(48), channel (8), rfcomm_cid (16) 990 rfcomm_event_incoming_connection_get_bd_addr(packet, event_addr); 991 hfp_connection = hfp_create_connection(event_addr, local_role); 992 if (!hfp_connection){ 993 log_info("hfp: no memory to accept incoming connection - decline"); 994 rfcomm_decline_connection(rfcomm_event_incoming_connection_get_rfcomm_cid(packet)); 995 return; 996 } 997 if (hfp_connection->state != HFP_IDLE) { 998 log_error("hfp: incoming connection but not idle, reject"); 999 rfcomm_decline_connection(rfcomm_event_incoming_connection_get_rfcomm_cid(packet)); 1000 return; 1001 } 1002 1003 hfp_connection->rfcomm_cid = rfcomm_event_incoming_connection_get_rfcomm_cid(packet); 1004 hfp_connection->state = HFP_W4_RFCOMM_CONNECTED; 1005 rfcomm_accept_connection(hfp_connection->rfcomm_cid); 1006 break; 1007 1008 case RFCOMM_EVENT_CHANNEL_OPENED: 1009 rfcomm_event_channel_opened_get_bd_addr(packet, event_addr); 1010 1011 hfp_connection = get_hfp_connection_context_for_bd_addr(event_addr, local_role); 1012 btstack_assert(hfp_connection != NULL); 1013 1014 if (hfp_connection->state != HFP_W4_RFCOMM_CONNECTED){ 1015 break; 1016 } 1017 1018 status = rfcomm_event_channel_opened_get_status(packet); 1019 if (status != ERROR_CODE_SUCCESS) { 1020 hfp_emit_slc_connection_event(hfp_connection, status, rfcomm_event_channel_opened_get_con_handle(packet), event_addr); 1021 hfp_finalize_connection_context(hfp_connection); 1022 break; 1023 } 1024 1025 hfp_connection->acl_handle = rfcomm_event_channel_opened_get_con_handle(packet); 1026 hfp_connection->rfcomm_cid = rfcomm_event_channel_opened_get_rfcomm_cid(packet); 1027 hfp_connection->rfcomm_mtu = rfcomm_event_channel_opened_get_max_frame_size(packet); 1028 bd_addr_copy(hfp_connection->remote_addr, event_addr); 1029 hfp_connection->state = HFP_EXCHANGE_SUPPORTED_FEATURES; 1030 1031 rfcomm_request_can_send_now_event(hfp_connection->rfcomm_cid); 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 { "+VGM=", HFP_CMD_SET_MICROPHONE_GAIN }, 1127 { "+VGS:", HFP_CMD_SET_SPEAKER_GAIN}, 1128 { "+VGS=", HFP_CMD_SET_SPEAKER_GAIN}, 1129 { "ERROR", HFP_CMD_ERROR}, 1130 { "NOP", HFP_CMD_NONE}, // dummy command used by unit tests 1131 { "OK", HFP_CMD_OK }, 1132 { "RING", HFP_CMD_RING }, 1133 }; 1134 1135 static hfp_command_t parse_command(const char * line_buffer, int isHandsFree){ 1136 1137 // table lookup based on role 1138 uint16_t num_entries; 1139 hfp_command_entry_t * table; 1140 if (isHandsFree == 0){ 1141 table = hfp_ag_commmand_table; 1142 num_entries = sizeof(hfp_ag_commmand_table) / sizeof(hfp_command_entry_t); 1143 } else { 1144 table = hfp_hf_commmand_table; 1145 num_entries = sizeof(hfp_hf_commmand_table) / sizeof(hfp_command_entry_t); 1146 } 1147 // binary search 1148 uint16_t left = 0; 1149 uint16_t right = num_entries - 1; 1150 while (left <= right){ 1151 uint16_t middle = left + (right - left) / 2; 1152 hfp_command_entry_t *entry = &table[middle]; 1153 int match = strcmp(line_buffer, entry->command); 1154 if (match < 0){ 1155 // search term is lower than middle element 1156 if (right == 0) break; 1157 right = middle - 1; 1158 } else if (match == 0){ 1159 return entry->command_id; 1160 } else { 1161 // search term is higher than middle element 1162 left = middle + 1; 1163 } 1164 } 1165 1166 // note: if parser in CMD_HEADER state would treats digits and maybe '+' as separator, match on "ATD" would work. 1167 // note: phone number is currently expected in line_buffer[3..] 1168 // prefix match on 'ATD', AG only 1169 if ((isHandsFree == 0) && (strncmp(line_buffer, HFP_CALL_PHONE_NUMBER, strlen(HFP_CALL_PHONE_NUMBER)) == 0)){ 1170 return HFP_CMD_CALL_PHONE_NUMBER; 1171 } 1172 1173 // Valid looking, but unknown commands/responses 1174 if ((isHandsFree == 0) && (strncmp(line_buffer, "AT+", 3) == 0)){ 1175 return HFP_CMD_UNKNOWN; 1176 } 1177 1178 if ((isHandsFree != 0) && (strncmp(line_buffer, "+", 1) == 0)){ 1179 return HFP_CMD_UNKNOWN; 1180 } 1181 1182 return HFP_CMD_NONE; 1183 } 1184 1185 static void hfp_parser_store_byte(hfp_connection_t * hfp_connection, uint8_t byte){ 1186 if ((hfp_connection->line_size + 1) >= HFP_MAX_VR_TEXT_SIZE) return; 1187 hfp_connection->line_buffer[hfp_connection->line_size++] = byte; 1188 hfp_connection->line_buffer[hfp_connection->line_size] = 0; 1189 } 1190 static int hfp_parser_is_buffer_empty(hfp_connection_t * hfp_connection){ 1191 return hfp_connection->line_size == 0; 1192 } 1193 1194 static int hfp_parser_is_end_of_line(uint8_t byte){ 1195 return (byte == '\n') || (byte == '\r'); 1196 } 1197 1198 static void hfp_parser_reset_line_buffer(hfp_connection_t *hfp_connection) { 1199 hfp_connection->line_size = 0; 1200 // hfp_connection->line_buffer[0] = 0; 1201 } 1202 1203 static void hfp_parser_store_if_token(hfp_connection_t * hfp_connection, uint8_t byte){ 1204 switch (byte){ 1205 case ',': 1206 case '-': 1207 case ';': 1208 case '(': 1209 case ')': 1210 case '\n': 1211 case '\r': 1212 break; 1213 default: 1214 hfp_parser_store_byte(hfp_connection, byte); 1215 break; 1216 } 1217 } 1218 1219 static bool hfp_parser_is_separator( uint8_t byte){ 1220 switch (byte){ 1221 case ',': 1222 case '-': 1223 case ';': 1224 case '\n': 1225 case '\r': 1226 return true; 1227 default: 1228 return false; 1229 } 1230 } 1231 1232 static bool hfp_parse_byte(hfp_connection_t * hfp_connection, uint8_t byte, int isHandsFree){ 1233 1234 // handle doubles quotes 1235 if (byte == '"'){ 1236 hfp_connection->parser_quoted = !hfp_connection->parser_quoted; 1237 return true; 1238 } 1239 if (hfp_connection->parser_quoted) { 1240 hfp_parser_store_byte(hfp_connection, byte); 1241 return true; 1242 } 1243 1244 // ignore spaces outside command or double quotes (required e.g. for '+CME ERROR:..") command 1245 if ((byte == ' ') && (hfp_connection->parser_state != HFP_PARSER_CMD_HEADER)) return true; 1246 1247 bool processed = true; 1248 1249 switch (hfp_connection->parser_state) { 1250 case HFP_PARSER_CMD_HEADER: 1251 switch (byte) { 1252 case '\n': 1253 case '\r': 1254 case ';': 1255 // ignore separator 1256 break; 1257 case ':': 1258 case '?': 1259 // store separator 1260 hfp_parser_store_byte(hfp_connection, byte); 1261 break; 1262 case '=': 1263 // equal sign: remember and wait for next char to decided between '=?' and '=\?' 1264 hfp_connection->found_equal_sign = true; 1265 hfp_parser_store_byte(hfp_connection, byte); 1266 return true; 1267 default: 1268 // store if not lookahead 1269 if (!hfp_connection->found_equal_sign) { 1270 hfp_parser_store_byte(hfp_connection, byte); 1271 return true; 1272 } 1273 // mark as lookahead 1274 processed = false; 1275 break; 1276 } 1277 1278 // ignore empty tokens 1279 if (hfp_parser_is_buffer_empty(hfp_connection)) return true; 1280 1281 // parse 1282 hfp_connection->command = parse_command((char *)hfp_connection->line_buffer, isHandsFree); 1283 1284 // pick +CIND version based on connection state: descriptions during SLC vs. states later 1285 if (hfp_connection->command == HFP_CMD_RETRIEVE_AG_INDICATORS_GENERIC){ 1286 switch(hfp_connection->state){ 1287 case HFP_W4_RETRIEVE_INDICATORS_STATUS: 1288 hfp_connection->command = HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS; 1289 break; 1290 case HFP_W4_RETRIEVE_INDICATORS: 1291 hfp_connection->command = HFP_CMD_RETRIEVE_AG_INDICATORS; 1292 break; 1293 default: 1294 hfp_connection->command = HFP_CMD_UNKNOWN; 1295 break; 1296 } 1297 } 1298 1299 log_info("command string '%s', handsfree %u -> cmd id %u", (char *)hfp_connection->line_buffer, isHandsFree, hfp_connection->command); 1300 1301 // next state 1302 hfp_connection->found_equal_sign = false; 1303 hfp_parser_reset_line_buffer(hfp_connection); 1304 hfp_connection->parser_state = HFP_PARSER_CMD_SEQUENCE; 1305 1306 return processed; 1307 1308 case HFP_PARSER_CMD_SEQUENCE: 1309 // handle empty fields 1310 if ((byte == ',' ) && (hfp_connection->line_size == 0)){ 1311 hfp_connection->line_buffer[0] = 0; 1312 hfp_connection->ignore_value = 1; 1313 parse_sequence(hfp_connection); 1314 return true; 1315 } 1316 1317 hfp_parser_store_if_token(hfp_connection, byte); 1318 if (!hfp_parser_is_separator(byte)) return true; 1319 1320 // ignore empty tokens 1321 switch (hfp_connection->command){ 1322 case HFP_CMD_AG_ACTIVATE_VOICE_RECOGNITION: 1323 // don't ignore empty string 1324 break; 1325 default: 1326 if (hfp_parser_is_buffer_empty(hfp_connection) && (hfp_connection->ignore_value == 0)) { 1327 return true; 1328 } 1329 break; 1330 } 1331 1332 parse_sequence(hfp_connection); 1333 1334 hfp_parser_reset_line_buffer(hfp_connection); 1335 1336 switch (hfp_connection->command){ 1337 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1338 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1339 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1340 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1341 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1342 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1343 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1344 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1345 case HFP_CMD_HF_INDICATOR_STATUS: 1346 hfp_connection->parser_state = HFP_PARSER_SECOND_ITEM; 1347 break; 1348 default: 1349 break; 1350 } 1351 return true; 1352 1353 case HFP_PARSER_SECOND_ITEM: 1354 1355 hfp_parser_store_if_token(hfp_connection, byte); 1356 if (!hfp_parser_is_separator(byte)) return true; 1357 1358 switch (hfp_connection->command){ 1359 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1360 log_info("format %s, ", hfp_connection->line_buffer); 1361 hfp_connection->network_operator.format = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1362 break; 1363 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1364 log_info("format %s \n", hfp_connection->line_buffer); 1365 hfp_connection->network_operator.format = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1366 break; 1367 case HFP_CMD_LIST_GENERIC_STATUS_INDICATORS: 1368 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS: 1369 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1370 hfp_connection->generic_status_indicators[hfp_connection->parser_item_index].state = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1371 break; 1372 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1373 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1374 log_info("%d \n", hfp_connection->ag_indicators[hfp_connection->parser_item_index].status); 1375 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status_changed = 1; 1376 break; 1377 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1378 hfp_connection->ag_indicators[hfp_connection->parser_item_index].min_range = btstack_atoi((char *)hfp_connection->line_buffer); 1379 log_info("%s, ", hfp_connection->line_buffer); 1380 break; 1381 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1382 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1383 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1384 hfp_connection->bnip_type = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1385 break; 1386 case HFP_CMD_HF_INDICATOR_STATUS: 1387 hfp_connection->parser_indicator_value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1388 break; 1389 default: 1390 break; 1391 } 1392 1393 hfp_parser_reset_line_buffer(hfp_connection); 1394 1395 hfp_connection->parser_state = HFP_PARSER_THIRD_ITEM; 1396 1397 return true; 1398 1399 case HFP_PARSER_THIRD_ITEM: 1400 1401 hfp_parser_store_if_token(hfp_connection, byte); 1402 if (!hfp_parser_is_separator(byte)) return true; 1403 1404 switch (hfp_connection->command){ 1405 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1406 strncpy(hfp_connection->network_operator.name, (char *)hfp_connection->line_buffer, HFP_MAX_NETWORK_OPERATOR_NAME_SIZE); 1407 hfp_connection->network_operator.name[HFP_MAX_NETWORK_OPERATOR_NAME_SIZE - 1] = 0; 1408 log_info("name %s\n", hfp_connection->line_buffer); 1409 break; 1410 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1411 hfp_connection->ag_indicators[hfp_connection->parser_item_index].max_range = btstack_atoi((char *)hfp_connection->line_buffer); 1412 hfp_next_indicators_index(hfp_connection); 1413 hfp_connection->ag_indicators_nr = hfp_connection->parser_item_index; 1414 log_info("%s)\n", hfp_connection->line_buffer); 1415 break; 1416 default: 1417 break; 1418 } 1419 1420 hfp_parser_reset_line_buffer(hfp_connection); 1421 1422 if (hfp_connection->command == HFP_CMD_RETRIEVE_AG_INDICATORS){ 1423 hfp_connection->parser_state = HFP_PARSER_CMD_SEQUENCE; 1424 } else { 1425 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 1426 } 1427 return true; 1428 1429 default: 1430 btstack_assert(false); 1431 return true; 1432 } 1433 } 1434 1435 void hfp_parse(hfp_connection_t * hfp_connection, uint8_t byte, int isHandsFree){ 1436 bool processed = false; 1437 while (!processed){ 1438 processed = hfp_parse_byte(hfp_connection, byte, isHandsFree); 1439 } 1440 // reset parser state on end-of-line 1441 if (hfp_parser_is_end_of_line(byte)){ 1442 hfp_connection->parser_item_index = 0; 1443 hfp_connection->parser_state = HFP_PARSER_CMD_HEADER; 1444 } 1445 } 1446 1447 static void parse_sequence(hfp_connection_t * hfp_connection){ 1448 int value; 1449 switch (hfp_connection->command){ 1450 case HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS: 1451 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1452 int i; 1453 switch (hfp_connection->parser_item_index){ 1454 case 0: 1455 for (i=0;i<hfp_connection->generic_status_indicators_nr;i++){ 1456 if (hfp_connection->generic_status_indicators[i].uuid == value){ 1457 hfp_connection->parser_indicator_index = i; 1458 break; 1459 } 1460 } 1461 break; 1462 case 1: 1463 if (hfp_connection->parser_indicator_index <0) break; 1464 hfp_connection->generic_status_indicators[hfp_connection->parser_indicator_index].state = value; 1465 log_info("HFP_CMD_SET_GENERIC_STATUS_INDICATOR_STATUS set indicator at index %u, to %u\n", 1466 hfp_connection->parser_item_index, value); 1467 break; 1468 default: 1469 break; 1470 } 1471 hfp_next_indicators_index(hfp_connection); 1472 break; 1473 1474 case HFP_CMD_GET_SUBSCRIBER_NUMBER_INFORMATION: 1475 switch(hfp_connection->parser_item_index){ 1476 case 0: 1477 // <alpha>: This optional field is not supported, and shall be left blank. 1478 break; 1479 case 1: 1480 // <number>: Quoted string containing the phone number in the format specified by <type>. 1481 strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number)); 1482 hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0; 1483 break; 1484 case 2: 1485 /* 1486 <type> field specifies the format of the phone number provided, and can be one of the following values: 1487 - 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. 1488 - 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. 1489 - values 160-175: National number. No prefix nor escape digits included. 1490 */ 1491 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1492 hfp_connection->bnip_type = value; 1493 break; 1494 case 3: 1495 // <speed>: This optional field is not supported, and shall be left blank. 1496 break; 1497 case 4: 1498 // <service>: Indicates which service this phone number relates to. Shall be either 4 (voice) or 5 (fax). 1499 default: 1500 break; 1501 } 1502 // index > 2 are ignored in switch above 1503 hfp_connection->parser_item_index++; 1504 break; 1505 case HFP_CMD_LIST_CURRENT_CALLS: 1506 switch(hfp_connection->parser_item_index){ 1507 case 0: 1508 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1509 hfp_connection->clcc_idx = value; 1510 break; 1511 case 1: 1512 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1513 hfp_connection->clcc_dir = value; 1514 break; 1515 case 2: 1516 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1517 hfp_connection->clcc_status = value; 1518 break; 1519 case 3: 1520 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1521 hfp_connection->clcc_mode = value; 1522 break; 1523 case 4: 1524 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1525 hfp_connection->clcc_mpty = value; 1526 break; 1527 case 5: 1528 strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number)); 1529 hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0; 1530 break; 1531 case 6: 1532 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1533 hfp_connection->bnip_type = value; 1534 break; 1535 default: 1536 break; 1537 } 1538 // index > 6 are ignored in switch above 1539 hfp_connection->parser_item_index++; 1540 break; 1541 case HFP_CMD_SET_MICROPHONE_GAIN: 1542 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1543 hfp_connection->microphone_gain = value; 1544 log_info("hfp parse HFP_CMD_SET_MICROPHONE_GAIN %d\n", value); 1545 break; 1546 case HFP_CMD_SET_SPEAKER_GAIN: 1547 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1548 hfp_connection->speaker_gain = value; 1549 log_info("hfp parse HFP_CMD_SET_SPEAKER_GAIN %d\n", value); 1550 break; 1551 case HFP_CMD_TURN_OFF_EC_AND_NR: 1552 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1553 hfp_connection->ag_echo_and_noise_reduction = value; 1554 log_info("hfp parse HFP_CMD_TURN_OFF_EC_AND_NR %d\n", value); 1555 break; 1556 case HFP_CMD_CHANGE_IN_BAND_RING_TONE_SETTING: 1557 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1558 hfp_connection->remote_supported_features = store_bit(hfp_connection->remote_supported_features, HFP_AGSF_IN_BAND_RING_TONE, value); 1559 log_info("hfp parse HFP_CHANGE_IN_BAND_RING_TONE_SETTING %d\n", value); 1560 break; 1561 case HFP_CMD_HF_CONFIRMED_CODEC: 1562 hfp_connection->codec_confirmed = btstack_atoi((char*)hfp_connection->line_buffer); 1563 log_info("hfp parse HFP_CMD_HF_CONFIRMED_CODEC %d\n", hfp_connection->codec_confirmed); 1564 break; 1565 case HFP_CMD_AG_SUGGESTED_CODEC: 1566 hfp_connection->suggested_codec = btstack_atoi((char*)hfp_connection->line_buffer); 1567 log_info("hfp parse HFP_CMD_AG_SUGGESTED_CODEC %d\n", hfp_connection->suggested_codec); 1568 break; 1569 case HFP_CMD_SUPPORTED_FEATURES: 1570 hfp_connection->remote_supported_features = btstack_atoi((char*)hfp_connection->line_buffer); 1571 log_info("Parsed supported feature %d\n", (int) hfp_connection->remote_supported_features); 1572 break; 1573 case HFP_CMD_AVAILABLE_CODECS: 1574 log_info("Parsed codec %s\n", hfp_connection->line_buffer); 1575 hfp_connection->remote_codecs[hfp_connection->parser_item_index] = (uint16_t)btstack_atoi((char*)hfp_connection->line_buffer); 1576 hfp_next_codec_index(hfp_connection); 1577 hfp_connection->remote_codecs_nr = hfp_connection->parser_item_index; 1578 break; 1579 case HFP_CMD_RETRIEVE_AG_INDICATORS: 1580 strncpy((char *)hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, (char *)hfp_connection->line_buffer, HFP_MAX_INDICATOR_DESC_SIZE); 1581 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name[HFP_MAX_INDICATOR_DESC_SIZE-1] = 0; 1582 hfp_connection->ag_indicators[hfp_connection->parser_item_index].index = hfp_connection->parser_item_index+1; 1583 log_info("Indicator %d: %s (", hfp_connection->ag_indicators_nr+1, hfp_connection->line_buffer); 1584 break; 1585 case HFP_CMD_RETRIEVE_AG_INDICATORS_STATUS: 1586 log_info("Parsed Indicator %d with status: %s\n", hfp_connection->parser_item_index+1, hfp_connection->line_buffer); 1587 hfp_connection->ag_indicators[hfp_connection->parser_item_index].status = btstack_atoi((char *) hfp_connection->line_buffer); 1588 hfp_next_indicators_index(hfp_connection); 1589 break; 1590 case HFP_CMD_ENABLE_INDICATOR_STATUS_UPDATE: 1591 hfp_next_indicators_index(hfp_connection); 1592 if (hfp_connection->parser_item_index != 4) break; 1593 log_info("Parsed Enable indicators: %s\n", hfp_connection->line_buffer); 1594 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1595 hfp_connection->enable_status_update_for_ag_indicators = (uint8_t) value; 1596 break; 1597 case HFP_CMD_SUPPORT_CALL_HOLD_AND_MULTIPARTY_SERVICES: 1598 log_info("Parsed Support call hold: %s\n", hfp_connection->line_buffer); 1599 if (hfp_connection->line_size > 2 ) break; 1600 memcpy((char *)hfp_connection->remote_call_services[hfp_connection->remote_call_services_index].name, (char *)hfp_connection->line_buffer, HFP_CALL_SERVICE_SIZE-1); 1601 hfp_connection->remote_call_services[hfp_connection->remote_call_services_index].name[HFP_CALL_SERVICE_SIZE - 1] = 0; 1602 hfp_next_remote_call_services_index(hfp_connection); 1603 break; 1604 case HFP_CMD_LIST_GENERIC_STATUS_INDICATORS: 1605 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS: 1606 log_info("Parsed Generic status indicator: %s\n", hfp_connection->line_buffer); 1607 hfp_connection->generic_status_indicators[hfp_connection->parser_item_index].uuid = (uint16_t)btstack_atoi((char*)hfp_connection->line_buffer); 1608 hfp_next_indicators_index(hfp_connection); 1609 hfp_connection->generic_status_indicators_nr = hfp_connection->parser_item_index; 1610 break; 1611 case HFP_CMD_RETRIEVE_GENERIC_STATUS_INDICATORS_STATE: 1612 // HF parses inital AG gen. ind. state 1613 log_info("Parsed List generic status indicator %s state: ", hfp_connection->line_buffer); 1614 hfp_connection->parser_item_index = hfp_parse_indicator_index(hfp_connection); 1615 break; 1616 case HFP_CMD_HF_INDICATOR_STATUS: 1617 hfp_connection->parser_indicator_index = hfp_parse_indicator_index(hfp_connection); 1618 log_info("Parsed HF indicator index %u", hfp_connection->parser_indicator_index); 1619 break; 1620 case HFP_CMD_ENABLE_INDIVIDUAL_AG_INDICATOR_STATUS_UPDATE: 1621 // AG parses new gen. ind. state 1622 if (hfp_connection->ignore_value){ 1623 hfp_connection->ignore_value = 0; 1624 log_info("Parsed Enable AG indicator pos %u('%s') - unchanged (stays %u)\n", hfp_connection->parser_item_index, 1625 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, hfp_connection->ag_indicators[hfp_connection->parser_item_index].enabled); 1626 } 1627 else if (hfp_connection->ag_indicators[hfp_connection->parser_item_index].mandatory){ 1628 log_info("Parsed Enable AG indicator pos %u('%s') - ignore (mandatory)\n", 1629 hfp_connection->parser_item_index, hfp_connection->ag_indicators[hfp_connection->parser_item_index].name); 1630 } else { 1631 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1632 hfp_connection->ag_indicators[hfp_connection->parser_item_index].enabled = value; 1633 log_info("Parsed Enable AG indicator pos %u('%s'): %u\n", hfp_connection->parser_item_index, 1634 hfp_connection->ag_indicators[hfp_connection->parser_item_index].name, value); 1635 } 1636 hfp_next_indicators_index(hfp_connection); 1637 break; 1638 case HFP_CMD_TRANSFER_AG_INDICATOR_STATUS: 1639 // indicators are indexed starting with 1 1640 hfp_connection->parser_item_index = hfp_parse_indicator_index(hfp_connection); 1641 log_info("Parsed status of the AG indicator %d, status ", hfp_connection->parser_item_index); 1642 break; 1643 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME: 1644 hfp_connection->network_operator.mode = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1645 log_info("Parsed network operator mode: %d, ", hfp_connection->network_operator.mode); 1646 break; 1647 case HFP_CMD_QUERY_OPERATOR_SELECTION_NAME_FORMAT: 1648 if (hfp_connection->line_buffer[0] == '3'){ 1649 log_info("Parsed Set network operator format : %s, ", hfp_connection->line_buffer); 1650 break; 1651 } 1652 // TODO emit ERROR, wrong format 1653 log_info("ERROR Set network operator format: index %s not supported\n", hfp_connection->line_buffer); 1654 break; 1655 case HFP_CMD_ERROR: 1656 break; 1657 case HFP_CMD_EXTENDED_AUDIO_GATEWAY_ERROR: 1658 hfp_connection->extended_audio_gateway_error = 1; 1659 hfp_connection->extended_audio_gateway_error_value = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1660 break; 1661 case HFP_CMD_ENABLE_EXTENDED_AUDIO_GATEWAY_ERROR: 1662 hfp_connection->enable_extended_audio_gateway_error_report = (uint8_t)btstack_atoi((char*)hfp_connection->line_buffer); 1663 hfp_connection->ok_pending = 1; 1664 hfp_connection->extended_audio_gateway_error = 0; 1665 break; 1666 case HFP_CMD_AG_SENT_PHONE_NUMBER: 1667 case HFP_CMD_AG_SENT_CALL_WAITING_NOTIFICATION_UPDATE: 1668 case HFP_CMD_AG_SENT_CLIP_INFORMATION: 1669 strncpy(hfp_connection->bnip_number, (char *)hfp_connection->line_buffer, sizeof(hfp_connection->bnip_number)); 1670 hfp_connection->bnip_number[sizeof(hfp_connection->bnip_number)-1] = 0; 1671 break; 1672 case HFP_CMD_CALL_HOLD: 1673 hfp_connection->ag_call_hold_action = hfp_connection->line_buffer[0] - '0'; 1674 if (hfp_connection->line_buffer[1] != '\0'){ 1675 hfp_connection->call_index = btstack_atoi((char *)&hfp_connection->line_buffer[1]); 1676 } 1677 break; 1678 case HFP_CMD_RESPONSE_AND_HOLD_COMMAND: 1679 hfp_connection->ag_response_and_hold_action = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1680 break; 1681 case HFP_CMD_TRANSMIT_DTMF_CODES: 1682 hfp_connection->ag_dtmf_code = hfp_connection->line_buffer[0]; 1683 break; 1684 case HFP_CMD_ENABLE_CLIP: 1685 hfp_connection->clip_enabled = hfp_connection->line_buffer[0] != '0'; 1686 break; 1687 case HFP_CMD_ENABLE_CALL_WAITING_NOTIFICATION: 1688 hfp_connection->call_waiting_notification_enabled = hfp_connection->line_buffer[0] != '0'; 1689 break; 1690 case HFP_CMD_HF_ACTIVATE_VOICE_RECOGNITION: 1691 value = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1692 hfp_connection->ag_activate_voice_recognition_value = value; 1693 break; 1694 case HFP_CMD_AG_ACTIVATE_VOICE_RECOGNITION: 1695 switch(hfp_connection->parser_item_index){ 1696 case 0: 1697 hfp_connection->ag_vra_status = btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1698 break; 1699 case 1: 1700 hfp_connection->ag_vra_state = (hfp_voice_recognition_state_t) btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1701 break; 1702 case 2: 1703 hfp_connection->ag_msg.text_id = 0; 1704 for (i = 0 ; i < 4; i++){ 1705 hfp_connection->ag_msg.text_id = (hfp_connection->ag_msg.text_id << 4) | nibble_for_char(hfp_connection->line_buffer[i]); 1706 } 1707 break; 1708 case 3: 1709 hfp_connection->ag_msg.text_type = (hfp_text_type_t) btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1710 break; 1711 case 4: 1712 hfp_connection->ag_msg.text_operation = (hfp_text_operation_t) btstack_atoi((char *)&hfp_connection->line_buffer[0]); 1713 break; 1714 case 5: 1715 hfp_connection->line_buffer[hfp_connection->line_size] = 0; 1716 hfp_connection->ag_vra_msg_length = hfp_connection->line_size + 1; 1717 break; 1718 default: 1719 break; 1720 } 1721 hfp_connection->parser_item_index++; 1722 break; 1723 default: 1724 break; 1725 } 1726 } 1727 1728 static void hfp_handle_start_sdp_client_query(void * context){ 1729 UNUSED(context); 1730 1731 btstack_linked_list_iterator_t it; 1732 btstack_linked_list_iterator_init(&it, &hfp_connections); 1733 while (btstack_linked_list_iterator_has_next(&it)){ 1734 hfp_connection_t * connection = (hfp_connection_t *)btstack_linked_list_iterator_next(&it); 1735 1736 if (connection->state != HFP_W2_SEND_SDP_QUERY) continue; 1737 1738 connection->state = HFP_W4_SDP_QUERY_COMPLETE; 1739 hfp_sdp_query_context.local_role = connection->local_role; 1740 (void)memcpy(hfp_sdp_query_context.remote_address, connection->remote_addr, 6); 1741 sdp_client_query_rfcomm_channel_and_name_for_service_class_uuid(&handle_query_rfcomm_event, connection->remote_addr, connection->service_uuid); 1742 return; 1743 } 1744 } 1745 1746 uint8_t hfp_establish_service_level_connection(bd_addr_t bd_addr, uint16_t service_uuid, hfp_role_t local_role){ 1747 hfp_connection_t * connection = get_hfp_connection_context_for_bd_addr(bd_addr, local_role); 1748 if (connection){ 1749 return ERROR_CODE_COMMAND_DISALLOWED; 1750 } 1751 1752 connection = hfp_create_connection(bd_addr, local_role); 1753 if (!connection){ 1754 return BTSTACK_MEMORY_ALLOC_FAILED; 1755 } 1756 1757 connection->state = HFP_W2_SEND_SDP_QUERY; 1758 1759 bd_addr_copy(connection->remote_addr, bd_addr); 1760 connection->service_uuid = service_uuid; 1761 1762 hfp_sdp_query_request.callback = &hfp_handle_start_sdp_client_query; 1763 // ignore ERROR_CODE_COMMAND_DISALLOWED because in that case, we already have requested an SDP callback 1764 (void) sdp_client_register_query_callback(&hfp_sdp_query_request); 1765 return ERROR_CODE_SUCCESS; 1766 } 1767 1768 void hfp_trigger_release_service_level_connection(hfp_connection_t * hfp_connection){ 1769 // called internally, NULL check already performed 1770 btstack_assert(hfp_connection != NULL); 1771 1772 hfp_trigger_release_audio_connection(hfp_connection); 1773 if (hfp_connection->state < HFP_W4_RFCOMM_CONNECTED){ 1774 hfp_connection->state = HFP_IDLE; 1775 return; 1776 } 1777 1778 if (hfp_connection->state == HFP_W4_RFCOMM_CONNECTED){ 1779 hfp_connection->state = HFP_W4_CONNECTION_ESTABLISHED_TO_SHUTDOWN; 1780 return; 1781 } 1782 hfp_connection->release_slc_connection = 1; 1783 if (hfp_connection->state < HFP_W4_SCO_CONNECTED){ 1784 hfp_connection->state = HFP_W2_DISCONNECT_RFCOMM; 1785 return; 1786 } 1787 1788 if (hfp_connection->state < HFP_W4_SCO_DISCONNECTED){ 1789 hfp_connection->state = HFP_W2_DISCONNECT_SCO; 1790 hfp_connection->release_audio_connection = 1; 1791 return; 1792 } 1793 } 1794 1795 uint8_t hfp_trigger_release_audio_connection(hfp_connection_t * hfp_connection){ 1796 // called internally, NULL check already performed 1797 btstack_assert(hfp_connection != NULL); 1798 if (hfp_connection->state <= HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED){ 1799 return ERROR_CODE_COMMAND_DISALLOWED; 1800 } 1801 switch (hfp_connection->state) { 1802 case HFP_W2_CONNECT_SCO: 1803 hfp_connection->state = HFP_SERVICE_LEVEL_CONNECTION_ESTABLISHED; 1804 break; 1805 case HFP_W4_SCO_CONNECTED: 1806 case HFP_AUDIO_CONNECTION_ESTABLISHED: 1807 hfp_connection->release_audio_connection = 1; 1808 break; 1809 default: 1810 return ERROR_CODE_COMMAND_DISALLOWED; 1811 } 1812 return ERROR_CODE_SUCCESS; 1813 } 1814 1815 static const struct link_settings { 1816 const uint16_t max_latency; 1817 const uint8_t retransmission_effort; 1818 const uint16_t packet_types; 1819 const bool eSCO; 1820 const uint8_t codec; 1821 } hfp_link_settings [] = { 1822 { 0xffff, 0xff, SCO_PACKET_TYPES_HV1, false, HFP_CODEC_CVSD }, // HFP_LINK_SETTINGS_D0 1823 { 0xffff, 0xff, SCO_PACKET_TYPES_HV3, false, HFP_CODEC_CVSD }, // HFP_LINK_SETTINGS_D1 1824 { 0x0007, 0x01, SCO_PACKET_TYPES_EV3, true, HFP_CODEC_CVSD }, // HFP_LINK_SETTINGS_S1 1825 { 0x0007, 0x01, SCO_PACKET_TYPES_2EV3, true, HFP_CODEC_CVSD }, // HFP_LINK_SETTINGS_S2 1826 { 0x000a, 0x01, SCO_PACKET_TYPES_2EV3, true, HFP_CODEC_CVSD }, // HFP_LINK_SETTINGS_S3 1827 { 0x000c, 0x02, SCO_PACKET_TYPES_2EV3, true, HFP_CODEC_CVSD }, // HFP_LINK_SETTINGS_S4 1828 { 0x0008, 0x02, SCO_PACKET_TYPES_EV3, true, HFP_CODEC_MSBC }, // HFP_LINK_SETTINGS_T1 1829 { 0x000d, 0x02, SCO_PACKET_TYPES_2EV3, true, HFP_CODEC_MSBC } // HFP_LINK_SETTINGS_T2 1830 }; 1831 1832 void hfp_setup_synchronous_connection(hfp_connection_t * hfp_connection){ 1833 // all packet types, fixed bandwidth 1834 int setting = hfp_connection->link_setting; 1835 log_info("hfp_setup_synchronous_connection using setting nr %u", setting); 1836 hfp_sco_establishment_active = hfp_connection; 1837 uint16_t sco_voice_setting = hci_get_sco_voice_setting(); 1838 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 1839 #ifdef ENABLE_BCM_PCM_WBS 1840 sco_voice_setting = 0x0063; // Transparent data, 16-bit for BCM controllers 1841 #else 1842 sco_voice_setting = 0x0043; // Transparent data, 8-bit otherwise 1843 #endif 1844 } 1845 // get packet types - bits 6-9 are 'don't allow' 1846 uint16_t packet_types = hfp_link_settings[setting].packet_types ^ 0x03c0; 1847 hci_send_cmd(&hci_setup_synchronous_connection, hfp_connection->acl_handle, 8000, 8000, hfp_link_settings[setting].max_latency, 1848 sco_voice_setting, hfp_link_settings[setting].retransmission_effort, packet_types); 1849 } 1850 1851 void hfp_accept_synchronous_connection(hfp_connection_t * hfp_connection, bool incoming_eSCO){ 1852 1853 // remote supported feature eSCO is set if link type is eSCO 1854 // eSCO: S4 - max latency == transmission interval = 0x000c == 12 ms, 1855 uint16_t max_latency; 1856 uint8_t retransmission_effort; 1857 uint16_t packet_types; 1858 1859 if (incoming_eSCO && hci_extended_sco_link_supported() && hci_remote_esco_supported(hfp_connection->acl_handle)){ 1860 max_latency = 0x000c; 1861 retransmission_effort = 0x02; 1862 // eSCO: EV3 and 2-EV3 1863 packet_types = 0x0048; 1864 } else { 1865 max_latency = 0xffff; 1866 retransmission_effort = 0xff; 1867 // sco: HV1 and HV3 1868 packet_types = 0x005; 1869 } 1870 1871 // mSBC only allows for transparent data 1872 uint16_t sco_voice_setting = hci_get_sco_voice_setting(); 1873 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 1874 #ifdef ENABLE_BCM_PCM_WBS 1875 sco_voice_setting = 0x0063; // Transparent data, 16-bit for BCM controllers 1876 #else 1877 sco_voice_setting = 0x0043; // Transparent data, 8-bit otherwise 1878 #endif 1879 } 1880 1881 // filter packet types 1882 packet_types &= hfp_get_sco_packet_types(); 1883 1884 // bits 6-9 are 'don't allow' 1885 packet_types ^= 0x3c0; 1886 1887 log_info("HFP: sending hci_accept_connection_request, packet types 0x%04x, sco_voice_setting 0x%02x", packet_types, sco_voice_setting); 1888 hci_send_cmd(&hci_accept_synchronous_connection, hfp_connection->remote_addr, 8000, 8000, max_latency, 1889 sco_voice_setting, retransmission_effort, packet_types); 1890 } 1891 1892 #ifdef ENABLE_CC256X_ASSISTED_HFP 1893 void hfp_cc256x_prepare_for_sco(hfp_connection_t * hfp_connection){ 1894 hfp_connection->cc256x_send_write_codec_config = true; 1895 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 1896 hfp_connection->cc256x_send_wbs_associate = true; 1897 } 1898 } 1899 1900 void hfp_cc256x_write_codec_config(hfp_connection_t * hfp_connection){ 1901 uint32_t sample_rate_hz; 1902 uint16_t clock_rate_khz; 1903 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 1904 clock_rate_khz = 512; 1905 sample_rate_hz = 16000; 1906 } else { 1907 clock_rate_khz = 256; 1908 sample_rate_hz = 8000; 1909 } 1910 uint8_t clock_direction = 0; // master 1911 uint16_t frame_sync_duty_cycle = 0; // i2s with 50% 1912 uint8_t frame_sync_edge = 1; // rising edge 1913 uint8_t frame_sync_polarity = 0; // active high 1914 uint8_t reserved = 0; 1915 uint16_t size = 16; 1916 uint16_t chan_1_offset = 1; 1917 uint16_t chan_2_offset = chan_1_offset + size; 1918 uint8_t out_edge = 1; // rising 1919 uint8_t in_edge = 0; // falling 1920 hci_send_cmd(&hci_ti_write_codec_config, clock_rate_khz, clock_direction, sample_rate_hz, frame_sync_duty_cycle, 1921 frame_sync_edge, frame_sync_polarity, reserved, 1922 size, chan_1_offset, out_edge, size, chan_1_offset, in_edge, reserved, 1923 size, chan_2_offset, out_edge, size, chan_2_offset, in_edge, reserved); 1924 } 1925 #endif 1926 1927 #ifdef ENABLE_BCM_PCM_WBS 1928 void hfp_bcm_prepare_for_sco(hfp_connection_t * hfp_connection){ 1929 hfp_connection->bcm_send_write_i2spcm_interface_param = true; 1930 if (hfp_connection->negotiated_codec == HFP_CODEC_MSBC){ 1931 hfp_connection->bcm_send_enable_wbs = true; 1932 } 1933 } 1934 void hfp_bcm_write_i2spcm_interface_param(hfp_connection_t * hfp_connection){ 1935 uint8_t sample_rate = (hfp_connection->negotiated_codec == HFP_CODEC_MSBC) ? 1 : 0; 1936 // i2s enable, master, 8/16 kHz, 512 kHz 1937 hci_send_cmd(&hci_bcm_write_i2spcm_interface_paramhci_bcm_write_i2spcm_interface_param, 1, 1, sample_rate, 2); 1938 } 1939 #endif 1940 1941 void hfp_set_hf_callback(btstack_packet_handler_t callback){ 1942 hfp_hf_callback = callback; 1943 } 1944 1945 void hfp_set_ag_callback(btstack_packet_handler_t callback){ 1946 hfp_ag_callback = callback; 1947 } 1948 1949 void hfp_set_ag_rfcomm_packet_handler(btstack_packet_handler_t handler){ 1950 hfp_ag_rfcomm_packet_handler = handler; 1951 } 1952 1953 void hfp_set_hf_rfcomm_packet_handler(btstack_packet_handler_t handler){ 1954 hfp_hf_rfcomm_packet_handler = handler; 1955 } 1956 1957 void hfp_init(void){ 1958 hfp_allowed_sco_packet_types = SCO_PACKET_TYPES_ALL; 1959 } 1960 1961 void hfp_deinit(void){ 1962 hfp_allowed_sco_packet_types = 0; 1963 hfp_connections = NULL; 1964 hfp_hf_callback = NULL; 1965 hfp_ag_callback = NULL; 1966 hfp_hf_rfcomm_packet_handler = NULL; 1967 hfp_ag_rfcomm_packet_handler = NULL; 1968 hfp_sco_establishment_active = NULL; 1969 (void) memset(&hfp_sdp_query_context, 0, sizeof(hfp_sdp_query_context_t)); 1970 (void) memset(&hfp_sdp_query_request, 0, sizeof(btstack_context_callback_registration_t)); 1971 } 1972 1973 void hfp_set_sco_packet_types(uint16_t packet_types){ 1974 hfp_allowed_sco_packet_types = packet_types; 1975 } 1976 1977 uint16_t hfp_get_sco_packet_types(void){ 1978 return hfp_allowed_sco_packet_types; 1979 } 1980 1981 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){ 1982 int8_t setting = (int8_t) current_setting; 1983 bool can_use_eSCO = local_eSCO_supported && remote_eSCO_supported; 1984 while (setting > 0){ 1985 setting--; 1986 // skip if eSCO required but not available 1987 if (hfp_link_settings[setting].eSCO && !can_use_eSCO) continue; 1988 // skip if S4 but not supported 1989 if ((setting == (int8_t) HFP_LINK_SETTINGS_S4) && !eSCO_S4_supported) continue; 1990 // skip wrong codec 1991 if ( hfp_link_settings[setting].codec != negotiated_codec) continue; 1992 // skip disabled packet types 1993 uint16_t required_packet_types = hfp_link_settings[setting].packet_types; 1994 uint16_t allowed_packet_types = hfp_allowed_sco_packet_types; 1995 if ((required_packet_types & allowed_packet_types) == 0) continue; 1996 1997 // found matching setting 1998 return (hfp_link_settings_t) setting; 1999 } 2000 return HFP_LINK_SETTINGS_NONE; 2001 } 2002 2003 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){ 2004 bool local_eSCO_supported = hci_extended_sco_link_supported(); 2005 bool remote_eSCO_supported = hci_remote_esco_supported(hfp_connection->acl_handle); 2006 uint8_t negotiated_codec = hfp_connection->negotiated_codec; 2007 return hfp_next_link_setting(current_setting, local_eSCO_supported, remote_eSCO_supported, eSCO_S4_supported, negotiated_codec); 2008 } 2009 2010 void hfp_init_link_settings(hfp_connection_t * hfp_connection, uint8_t eSCO_S4_supported){ 2011 // get highest possible link setting 2012 hfp_connection->link_setting = hfp_next_link_setting_for_connection(HFP_LINK_SETTINGS_NONE, hfp_connection, eSCO_S4_supported); 2013 log_info("hfp_init_link_settings: %u", hfp_connection->link_setting); 2014 } 2015 2016 #define HFP_HF_RX_DEBUG_PRINT_LINE 80 2017 2018 void hfp_log_rfcomm_message(const char * tag, uint8_t * packet, uint16_t size){ 2019 #ifdef ENABLE_LOG_INFO 2020 // encode \n\r 2021 char printable[HFP_HF_RX_DEBUG_PRINT_LINE+2]; 2022 int i = 0; 2023 int pos; 2024 for (pos=0 ; (pos < size) && (i < (HFP_HF_RX_DEBUG_PRINT_LINE - 3)) ; pos++){ 2025 switch (packet[pos]){ 2026 case '\n': 2027 printable[i++] = '\\'; 2028 printable[i++] = 'n'; 2029 break; 2030 case '\r': 2031 printable[i++] = '\\'; 2032 printable[i++] = 'r'; 2033 break; 2034 default: 2035 printable[i++] = packet[pos]; 2036 break; 2037 } 2038 } 2039 printable[i] = 0; 2040 log_info("%s: '%s'", tag, printable); 2041 #endif 2042 } 2043