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