1 /* Copyright (c) 2013 The Chromium OS Authors. All rights reserved. 2 * Use of this source code is governed by a BSD-style license that can be 3 * found in the LICENSE file. 4 */ 5 6 #include <sys/socket.h> 7 #include <syslog.h> 8 9 #include "cras_bt_device.h" 10 #include "cras_telephony.h" 11 #include "cras_hfp_ag_profile.h" 12 #include "cras_hfp_slc.h" 13 #include "cras_system_state.h" 14 15 #define SLC_BUF_SIZE_BYTES 256 16 17 /* Indicator update command response and indicator indices. 18 * Note that indicator index starts from '1'. 19 */ 20 #define BATTERY_IND_INDEX 1 21 #define SIGNAL_IND_INDEX 2 22 #define SERVICE_IND_INDEX 3 23 #define CALL_IND_INDEX 4 24 #define CALLSETUP_IND_INDEX 5 25 #define CALLHELD_IND_INDEX 6 26 #define INDICATOR_UPDATE_RSP \ 27 "+CIND: " \ 28 "(\"battchg\",(0-5))," \ 29 "(\"signal\",(0-5))," \ 30 "(\"service\",(0,1))," \ 31 "(\"call\",(0,1))," \ 32 "(\"callsetup\",(0-3))," \ 33 "(\"callheld\",(0-2))," \ 34 "(\"roam\",(0,1))" \ 35 "" 36 /* Mode values for standard event reporting activation/deactivation AT 37 * command AT+CMER. Used for indicator events reporting in HFP. */ 38 #define FORWARD_UNSOLICIT_RESULT_CODE 3 39 40 /* Handle object to hold required info to initialize and maintain 41 * an HFP service level connection. 42 * Args: 43 * buf - Buffer hold received commands. 44 * buf_read_idx - Read index for buf. 45 * buf_write_idx - Write index for buf. 46 * rfcomm_fd - File descriptor for the established RFCOMM connection. 47 * init_cb - Callback to be triggered when an SLC is initialized. 48 * initialized - The service level connection is fully initilized of not. 49 * cli_active - Calling line identification notification is enabled or not. 50 * battery - Current battery level of AG stored in SLC. 51 * signal - Current signal strength of AG stored in SLC. 52 * service - Current service availability of AG stored in SLC. 53 * callheld - Current callheld status of AG stored in SLC. 54 * ind_event_report - Activate status of indicator events reporting. 55 * telephony - A reference of current telephony handle. 56 * device - The associated bt device. 57 */ 58 struct hfp_slc_handle { 59 char buf[SLC_BUF_SIZE_BYTES]; 60 int buf_read_idx; 61 int buf_write_idx; 62 63 int is_hsp; 64 int rfcomm_fd; 65 hfp_slc_init_cb init_cb; 66 hfp_slc_disconnect_cb disconnect_cb; 67 int initialized; 68 int cli_active; 69 int battery; 70 int signal; 71 int service; 72 int callheld; 73 int ind_event_report; 74 struct cras_bt_device *device; 75 76 struct cras_telephony_handle *telephony; 77 }; 78 79 /* AT command exchanges between AG(Audio gateway) and HF(Hands-free device) */ 80 struct at_command { 81 const char *cmd; 82 int (*callback) (struct hfp_slc_handle *handle, const char *cmd); 83 }; 84 85 /* Sends a response or command to HF */ 86 static int hfp_send(struct hfp_slc_handle *handle, const char *buf) 87 { 88 int written, err, len; 89 90 if (handle->rfcomm_fd < 0) 91 return -EIO; 92 93 /* Message start and end with "\r\n". refer to spec 4.33. */ 94 err = write(handle->rfcomm_fd, "\r\n", 2); 95 if (err < 0) 96 return -errno; 97 98 len = strlen(buf); 99 written = 0; 100 while (written < len) { 101 err = write(handle->rfcomm_fd, 102 buf + written, len - written); 103 if (err < 0) 104 return -errno; 105 written += err; 106 } 107 108 err = write(handle->rfcomm_fd, "\r\n", 2); 109 if (err < 0) 110 return -errno; 111 112 return 0; 113 } 114 115 /* Sends a response for indicator event reporting. */ 116 static int hfp_send_ind_event_report(struct hfp_slc_handle *handle, 117 int ind_index, 118 int value) 119 { 120 char cmd[64]; 121 122 if (handle->is_hsp || !handle->ind_event_report) 123 return 0; 124 125 snprintf(cmd, 64, "+CIEV: %d,%d", ind_index, value); 126 return hfp_send(handle, cmd); 127 } 128 129 /* Sends calling line identification unsolicited result code and 130 * standard call waiting notification. */ 131 static int hfp_send_calling_line_identification(struct hfp_slc_handle *handle, 132 const char *number, 133 int type) 134 { 135 char cmd[64]; 136 137 if (handle->is_hsp) 138 return 0; 139 140 if (handle->telephony->call) { 141 snprintf(cmd, 64, "+CCWA: \"%s\",%d", number, type); 142 } else { 143 snprintf(cmd, 64, "+CLIP: \"%s\",%d", number, type); 144 } 145 return hfp_send(handle, cmd); 146 } 147 148 /* ATA command to accept an incoming call. Mandatory support per spec 4.13. */ 149 static int answer_call(struct hfp_slc_handle *handle, const char *cmd) 150 { 151 int rc; 152 rc = hfp_send(handle, "OK"); 153 if (rc) 154 return rc; 155 156 return cras_telephony_event_answer_call(); 157 } 158 159 /* AT+CCWA command to enable the "Call Waiting notification" function. 160 * Mandatory support per spec 4.21. */ 161 static int call_waiting_notify(struct hfp_slc_handle *handle, const char *buf) 162 { 163 return hfp_send(handle, "OK"); 164 } 165 166 /* AT+CLIP command to enable the "Calling Line Identification notification" 167 * function. Mandatory per spec 4.23. 168 */ 169 static int cli_notification(struct hfp_slc_handle *handle, const char *cmd) 170 { 171 handle->cli_active = (cmd[8] == '1'); 172 return hfp_send(handle, "OK"); 173 } 174 175 /* ATDdd...dd command to place call with supplied number, or ATD>nnn... 176 * command to dial the number stored at memory location. Mandatory per 177 * spec 4.18 and 4.19. 178 */ 179 static int dial_number(struct hfp_slc_handle *handle, const char *cmd) 180 { 181 int rc, cmd_len; 182 183 cmd_len = strlen(cmd); 184 185 if (cmd[3] == '>') { 186 /* Handle memory dial. Extract memory location from command 187 * ATD>nnn...; and lookup. */ 188 int memory_location; 189 memory_location = strtol(cmd + 4, NULL, 0); 190 if (handle->telephony->dial_number == NULL || memory_location != 1) 191 return hfp_send(handle, "ERROR"); 192 } 193 else { 194 /* ATDddddd; Store dial number to the only memory slot. */ 195 cras_telephony_store_dial_number(cmd_len - 3 - 1, cmd + 3); 196 } 197 198 rc = hfp_send(handle, "OK"); 199 if (rc) 200 return rc; 201 202 handle->telephony->callsetup = 2; 203 return hfp_send_ind_event_report(handle, CALLSETUP_IND_INDEX, 2); 204 } 205 206 /* AT+VTS command to generate a DTMF code. Mandatory per spec 4.27. */ 207 static int dtmf_tone(struct hfp_slc_handle *handle, const char *buf) 208 { 209 return hfp_send(handle, "OK"); 210 } 211 212 /* AT+CMER command enables the registration status update function in AG. 213 * The service level connection is consider initialized when successfully 214 * responded OK to the AT+CMER command. Mandatory support per spec 4.4. 215 */ 216 static int event_reporting(struct hfp_slc_handle *handle, const char *cmd) 217 { 218 char *tokens, *mode, *tmp; 219 int err = 0; 220 221 /* AT+CMER=[<mode>[,<keyp>[,<disp>[,<ind> [,<bfr>]]]]] 222 * Parse <ind>, the only token we care about. 223 */ 224 tokens = strdup(cmd); 225 strtok(tokens, "="); 226 227 mode = strtok(NULL, ","); 228 tmp = strtok(NULL, ","); 229 tmp = strtok(NULL, ","); 230 tmp = strtok(NULL, ","); 231 232 /* mode = 3 for forward unsolicited result codes. 233 * AT+CMER=3,0,0,1 activates indicator events reporting. 234 * The service level connection is considered established after 235 * successfully responded with OK, regardless of the indicator 236 * events reporting status. 237 */ 238 if (!mode || !tmp) { 239 syslog(LOG_ERR, "Invalid event reporting cmd %s", cmd); 240 err = -EINVAL; 241 goto event_reporting_err; 242 } 243 if (atoi(mode) == FORWARD_UNSOLICIT_RESULT_CODE) 244 handle->ind_event_report = atoi(tmp); 245 246 err = hfp_send(handle, "OK"); 247 if (err) { 248 syslog(LOG_ERR, "Error sending response for command %s", cmd); 249 goto event_reporting_err; 250 } 251 252 /* Consider the Service Level Connection to be fully initialized, 253 * and thereby established, after successfully responded with OK. 254 */ 255 if (!handle->initialized) { 256 handle->initialized = 1; 257 if (handle->init_cb) 258 handle->init_cb(handle); 259 } 260 261 event_reporting_err: 262 free(tokens); 263 return err; 264 } 265 266 /* AT+CMEE command to set the "Extended Audio Gateway Error Result Code". 267 * Mandatory per spec 4.9. 268 */ 269 static int extended_errors(struct hfp_slc_handle *handle, const char *buf) 270 { 271 return hfp_send(handle, "OK"); 272 } 273 274 /* AT+CKPD command to handle the user initiated action from headset profile 275 * device. 276 */ 277 static int key_press(struct hfp_slc_handle *handle, const char *buf) 278 { 279 hfp_send(handle, "OK"); 280 281 /* Release the call and connection. */ 282 if (handle->telephony->call || handle->telephony->callsetup) { 283 cras_telephony_event_terminate_call(); 284 handle->disconnect_cb(handle); 285 return -EIO; 286 } 287 return 0; 288 } 289 290 /* AT+BLDN command to re-dial the last number. Mandatory support 291 * per spec 4.20. 292 */ 293 static int last_dialed_number(struct hfp_slc_handle *handle, const char *buf) 294 { 295 int rc; 296 297 if (!handle->telephony->dial_number) 298 return hfp_send(handle, "ERROR"); 299 300 rc = hfp_send(handle, "OK"); 301 if (rc) 302 return rc; 303 304 handle->telephony->callsetup = 2; 305 return hfp_send_ind_event_report(handle, CALLSETUP_IND_INDEX, 2); 306 } 307 308 /* AT+CLCC command to query list of current calls. Mandatory support 309 * per spec 4.31. 310 * 311 * +CLCC: <idx>,<direction>,<status>,<mode>,<multiparty> 312 */ 313 static int list_current_calls(struct hfp_slc_handle *handle, const char *cmd) 314 { 315 char buf[64]; 316 317 int idx = 1; 318 int rc; 319 /* Fake the call list base on callheld and call status 320 * since we have no API exposed to manage call list. 321 * This is a hack to pass qualification test which ask us to 322 * handle the basic case that one call is active and 323 * the other is on hold. */ 324 if (handle->telephony->callheld) 325 { 326 snprintf(buf, 64, "+CLCC: %d,1,1,0,0", idx++); 327 rc = hfp_send(handle, buf); 328 if (rc) 329 return rc; 330 } 331 332 if (handle->telephony->call) 333 { 334 snprintf(buf, 64, "+CLCC: %d,1,0,0,0", idx++); 335 rc = hfp_send(handle, buf); 336 if (rc) 337 return rc; 338 } 339 340 return hfp_send(handle, "OK"); 341 } 342 343 /* AT+COPS command to query currently selected operator or set name format. 344 * Mandatory support per spec 4.8. 345 */ 346 static int operator_selection(struct hfp_slc_handle *handle, const char *buf) 347 { 348 int rc; 349 if (buf[7] == '?') 350 { 351 /* HF sends AT+COPS? command to find current network operator. 352 * AG responds with +COPS:<mode>,<format>,<operator>, where 353 * the mode=0 means automatic for network selection. If no 354 * operator is selected, <format> and <operator> are omitted. 355 */ 356 rc = hfp_send(handle, "+COPS: 0"); 357 if (rc) 358 return rc; 359 } 360 return hfp_send(handle, "OK"); 361 } 362 363 /* AT+CIND command retrieves the supported indicator and its corresponding 364 * range and order index or read current status of indicators. Mandatory 365 * support per spec 4.2. 366 */ 367 static int report_indicators(struct hfp_slc_handle *handle, const char *cmd) 368 { 369 int err; 370 char buf[64]; 371 372 if (cmd[7] == '=') { 373 /* Indicator update test command "AT+CIND=?" */ 374 err = hfp_send(handle, INDICATOR_UPDATE_RSP); 375 } else { 376 /* Indicator update read command "AT+CIND?". 377 * Respond with current status of AG indicators, 378 * the values must be listed in the indicator order declared 379 * in INDICATOR_UPDATE_RSP. 380 * +CIND: <signal>,<service>,<call>, 381 * <callsetup>,<callheld>,<roam> 382 */ 383 snprintf(buf, 64, "+CIND: %d,%d,%d,%d,%d,%d,0", 384 handle->battery, 385 handle->signal, 386 handle->service, 387 handle->telephony->call, 388 handle->telephony->callsetup, 389 handle->telephony->callheld 390 ); 391 err = hfp_send(handle, buf); 392 } 393 394 if (err < 0) 395 return err; 396 397 return hfp_send(handle, "OK"); 398 } 399 400 /* AT+BIA command to change the subset of indicators that shall be 401 * sent by the AG. It is okay to ignore this command here since we 402 * don't do event reporting(CMER). 403 */ 404 static int indicator_activation(struct hfp_slc_handle *handle, const char *cmd) 405 { 406 /* AT+BIA=[[<indrep 1>][,[<indrep 2>][,...[,[<indrep n>]]]]] */ 407 syslog(LOG_ERR, "Bluetooth indicator activation command %s", cmd); 408 return hfp_send(handle, "OK"); 409 } 410 411 /* AT+VGM and AT+VGS command reports the current mic and speaker gain 412 * level respectively. Optional support per spec 4.28. 413 */ 414 static int signal_gain_setting(struct hfp_slc_handle *handle, 415 const char *cmd) 416 { 417 int gain; 418 419 if (strlen(cmd) < 8) { 420 syslog(LOG_ERR, "Invalid gain setting command %s", cmd); 421 return -EINVAL; 422 } 423 424 /* Map 0 to the smallest non-zero scale 6/100, and 15 to 425 * 100/100 full. */ 426 if (cmd[5] == 'S') { 427 gain = atoi(&cmd[7]); 428 cras_bt_device_update_hardware_volume(handle->device, 429 (gain + 1) * 100 / 16); 430 } 431 432 return hfp_send(handle, "OK"); 433 } 434 435 /* AT+CNUM command to query the subscriber number. Mandatory support 436 * per spec 4.30. 437 */ 438 static int subscriber_number(struct hfp_slc_handle *handle, const char *buf) 439 { 440 return hfp_send(handle, "OK"); 441 } 442 443 /* AT+BRSF command notifies the HF(Hands-free device) supported features 444 * and retrieves the AG(Audio gateway) supported features. Mandatory 445 * support per spec 4.2. 446 */ 447 static int supported_features(struct hfp_slc_handle *handle, const char *cmd) 448 { 449 int err; 450 char response[128]; 451 if (strlen(cmd) < 9) 452 return -EINVAL; 453 454 /* AT+BRSF=<feature> command received, ignore the HF supported feature 455 * for now. Respond with +BRSF:<feature> to notify mandatory supported 456 * features in AG(audio gateway). 457 */ 458 snprintf(response, 128, "+BRSF: %u", HFP_SUPPORTED_FEATURE); 459 err = hfp_send(handle, response); 460 if (err < 0) 461 return err; 462 463 return hfp_send(handle, "OK"); 464 } 465 466 int hfp_event_speaker_gain(struct hfp_slc_handle *handle, int gain) 467 { 468 char command[128]; 469 470 /* Normailize gain value to 0-15 */ 471 gain = gain * 15 / 100; 472 snprintf(command, 128, "+VGS=%d", gain); 473 474 return hfp_send(handle, command); 475 } 476 477 /* AT+CHUP command to terminate current call. Mandatory support 478 * per spec 4.15. 479 */ 480 static int terminate_call(struct hfp_slc_handle *handle, const char *cmd) 481 { 482 int rc; 483 rc = hfp_send(handle, "OK"); 484 if (rc) 485 return rc; 486 487 return cras_telephony_event_terminate_call(); 488 } 489 490 /* AT commands to support in order to conform HFP specification. 491 * 492 * An initialized service level connection is the pre-condition for all 493 * call related procedures. Note that for the call related commands, 494 * we are good to just respond with a dummy "OK". 495 * 496 * The procedure to establish a service level connection is described below: 497 * 498 * 1. HF notifies AG about its own supported features and AG responds 499 * with its supported feature. 500 * 501 * HF(hands-free) AG(audio gateway) 502 * AT+BRSF=<HF supported feature> --> 503 * <-- +BRSF:<AG supported feature> 504 * <-- OK 505 * 506 * 2. HF retrieves the information about the indicators supported in AG. 507 * 508 * HF(hands-free) AG(audio gateway) 509 * AT+CIND=? --> 510 * <-- +CIND:... 511 * <-- OK 512 * 513 * 3. The HF requests the current status of the indicators in AG. 514 * 515 * HF(hands-free) AG(audio gateway) 516 * AT+CIND --> 517 * <-- +CIND:... 518 * <-- OK 519 * 520 * 4. HF requests enabling indicator status update in the AG. 521 * 522 * HF(hands-free) AG(audio gateway) 523 * AT+CMER= --> 524 * <-- OK 525 */ 526 static struct at_command at_commands[] = { 527 { "ATA", answer_call }, 528 { "ATD", dial_number }, 529 { "AT+BIA", indicator_activation }, 530 { "AT+BLDN", last_dialed_number }, 531 { "AT+BRSF", supported_features }, 532 { "AT+CCWA", call_waiting_notify }, 533 { "AT+CHUP", terminate_call }, 534 { "AT+CIND", report_indicators }, 535 { "AT+CKPD", key_press }, 536 { "AT+CLCC", list_current_calls }, 537 { "AT+CLIP", cli_notification }, 538 { "AT+CMEE", extended_errors }, 539 { "AT+CMER", event_reporting }, 540 { "AT+CNUM", subscriber_number }, 541 { "AT+COPS", operator_selection }, 542 { "AT+VG", signal_gain_setting }, 543 { "AT+VTS", dtmf_tone }, 544 { 0 } 545 }; 546 547 static int handle_at_command(struct hfp_slc_handle *slc_handle, 548 const char *cmd) { 549 struct at_command *atc; 550 551 for (atc = at_commands; atc->cmd; atc++) 552 if (!strncmp(cmd, atc->cmd, strlen(atc->cmd))) 553 return atc->callback(slc_handle, cmd); 554 555 syslog(LOG_ERR, "AT command %s not supported", cmd); 556 return hfp_send(slc_handle, "ERROR"); 557 } 558 559 static void slc_watch_callback(void *arg) 560 { 561 struct hfp_slc_handle *handle = (struct hfp_slc_handle *)arg; 562 ssize_t bytes_read; 563 int err; 564 565 bytes_read = read(handle->rfcomm_fd, 566 &handle->buf[handle->buf_write_idx], 567 SLC_BUF_SIZE_BYTES - handle->buf_write_idx - 1); 568 if (bytes_read < 0) { 569 syslog(LOG_ERR, "Error reading slc command %s", 570 strerror(errno)); 571 handle->disconnect_cb(handle); 572 return; 573 } 574 handle->buf_write_idx += bytes_read; 575 handle->buf[handle->buf_write_idx] = '\0'; 576 577 while (handle->buf_read_idx != handle->buf_write_idx) { 578 char *end_char; 579 end_char = strchr(&handle->buf[handle->buf_read_idx], '\r'); 580 if (end_char == NULL) 581 break; 582 583 *end_char = '\0'; 584 err = handle_at_command(handle, 585 &handle->buf[handle->buf_read_idx]); 586 if (err < 0) 587 return; 588 589 /* Shift the read index */ 590 handle->buf_read_idx = 1 + end_char - handle->buf; 591 if (handle->buf_read_idx == handle->buf_write_idx) { 592 handle->buf_read_idx = 0; 593 handle->buf_write_idx = 0; 594 } 595 } 596 597 /* Handle the case when buffer is full and no command found. */ 598 if (handle->buf_write_idx == SLC_BUF_SIZE_BYTES - 1) { 599 if (handle->buf_read_idx) { 600 memmove(handle->buf, 601 &handle->buf[handle->buf_read_idx], 602 handle->buf_write_idx - handle->buf_read_idx); 603 handle->buf_write_idx -= handle->buf_read_idx; 604 handle->buf_read_idx = 0; 605 } else { 606 syslog(LOG_ERR, 607 "Parse SLC command error, clean up buffer"); 608 handle->buf_write_idx = 0; 609 } 610 } 611 612 return; 613 } 614 615 /* Exported interfaces */ 616 617 struct hfp_slc_handle *hfp_slc_create(int fd, 618 int is_hsp, 619 struct cras_bt_device *device, 620 hfp_slc_init_cb init_cb, 621 hfp_slc_disconnect_cb disconnect_cb) 622 { 623 struct hfp_slc_handle *handle; 624 625 handle = (struct hfp_slc_handle*) calloc(1, sizeof(*handle)); 626 if (!handle) 627 return NULL; 628 629 handle->rfcomm_fd = fd; 630 handle->is_hsp = is_hsp; 631 handle->device = device; 632 handle->init_cb = init_cb; 633 handle->disconnect_cb = disconnect_cb; 634 handle->cli_active = 0; 635 handle->battery = 5; 636 handle->signal = 5; 637 handle->service = 1; 638 handle->ind_event_report = 0; 639 handle->telephony = cras_telephony_get(); 640 641 cras_system_add_select_fd(handle->rfcomm_fd, 642 slc_watch_callback, handle); 643 644 return handle; 645 } 646 647 void hfp_slc_destroy(struct hfp_slc_handle *slc_handle) 648 { 649 cras_system_rm_select_fd(slc_handle->rfcomm_fd); 650 close(slc_handle->rfcomm_fd); 651 free(slc_handle); 652 } 653 654 int hfp_set_call_status(struct hfp_slc_handle *handle, int call) 655 { 656 int old_call = handle->telephony->call; 657 658 if (old_call == call) 659 return 0; 660 661 handle->telephony->call = call; 662 return hfp_event_update_call(handle); 663 } 664 665 /* Procedure to setup a call when AG sees incoming call. 666 * 667 * HF(hands-free) AG(audio gateway) 668 * <-- Incoming call 669 * <-- +CIEV: (callsetup = 1) 670 * <-- RING (ALERT) 671 */ 672 int hfp_event_incoming_call(struct hfp_slc_handle *handle, 673 const char *number, 674 int type) 675 { 676 int rc; 677 678 if (handle->is_hsp) 679 return 0; 680 681 if (handle->cli_active) { 682 rc = hfp_send_calling_line_identification(handle, number, type); 683 if (rc) 684 return rc; 685 } 686 687 if (handle->telephony->call) 688 return 0; 689 else 690 return hfp_send(handle, "RING"); 691 } 692 693 int hfp_event_update_call(struct hfp_slc_handle *handle) 694 { 695 return hfp_send_ind_event_report(handle, CALL_IND_INDEX, 696 handle->telephony->call); 697 } 698 699 int hfp_event_update_callsetup(struct hfp_slc_handle *handle) 700 { 701 return hfp_send_ind_event_report(handle, CALLSETUP_IND_INDEX, 702 handle->telephony->callsetup); 703 } 704 705 int hfp_event_update_callheld(struct hfp_slc_handle *handle) 706 { 707 return hfp_send_ind_event_report(handle, CALLHELD_IND_INDEX, 708 handle->telephony->callheld); 709 } 710 711 int hfp_event_set_battery(struct hfp_slc_handle *handle, int level) 712 { 713 handle->battery = level; 714 return hfp_send_ind_event_report(handle, BATTERY_IND_INDEX, level); 715 } 716 717 int hfp_event_set_signal(struct hfp_slc_handle *handle, int level) 718 { 719 handle->signal = level; 720 return hfp_send_ind_event_report(handle, SIGNAL_IND_INDEX, level); 721 } 722 723 int hfp_event_set_service(struct hfp_slc_handle *handle, int avail) 724 { 725 /* Convert to 0 or 1. 726 * Since the value must be either 1 or 0. (service presence or not) */ 727 handle->service = !!avail; 728 return hfp_send_ind_event_report(handle, SERVICE_IND_INDEX, avail); 729 } 730
