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