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