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