android/hal-audio.c

   1 /*
   2  * Copyright (C) 2013 Intel Corporation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <errno.h>
  19 #include <pthread.h>
  20 #include <poll.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/socket.h>
  25 #include <sys/un.h>
  26 #include <unistd.h>
  27
  28 #include <hardware/audio.h>
  29 #include <hardware/hardware.h>
  30
  31 #include "audio-msg.h"
  32 #include "hal-log.h"
  33 #include "hal-msg.h"
  34 #include "../profiles/audio/a2dp-codecs.h"
  35
  36 static const uint8_t a2dp_src_uuid[] = {
  37                 0x00, 0x00, 0x11, 0x0a, 0x00, 0x00, 0x10, 0x00,
  38                 0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb };
  39
  40 static int listen_sk = -1;
  41 static int audio_sk = -1;
  42 static bool close_thread = false;
  43
  44 static pthread_t ipc_th = 0;
  45 static pthread_mutex_t close_mutex = PTHREAD_MUTEX_INITIALIZER;
  46 static pthread_mutex_t sk_mutex = PTHREAD_MUTEX_INITIALIZER;
  47
  48 struct audio_input_config {
  49         uint32_t rate;
  50         uint32_t channels;
  51         audio_format_t format;
  52 };
  53
  54 static int sbc_get_presets(struct audio_preset *preset, size_t *len);
  55
  56 struct audio_codec {
  57         uint8_t type;
  58
  59         int (*get_presets) (struct audio_preset *preset, size_t *len);
  60
  61         int (*init) (struct audio_preset *preset, void **codec_data);
  62         int (*cleanup) (void *codec_data);
  63         int (*get_config) (void *codec_data,
  64                                         struct audio_input_config *config);
  65         ssize_t (*write_data) (void *codec_data, const void *buffer,
  66                                 size_t bytes);
  67 };
  68
  69 static const struct audio_codec audio_codecs[] = {
  70         {
  71                 .type = A2DP_CODEC_SBC,
  72
  73                 .get_presets = sbc_get_presets,
  74         }
  75 };
  76
  77 #define NUM_CODECS (sizeof(audio_codecs) / sizeof(audio_codecs[0]))
  78
  79 #define MAX_AUDIO_ENDPOINTS NUM_CODECS
  80
  81 struct audio_endpoint {
  82         uint8_t id;
  83         const struct audio_codec *codec;
  84         void *codec_data;
  85         int fd;
  86 };
  87
  88 static struct audio_endpoint audio_endpoints[MAX_AUDIO_ENDPOINTS];
  89
  90 enum a2dp_state_t {
  91         AUDIO_A2DP_STATE_NONE,
  92         AUDIO_A2DP_STATE_STANDBY,
  93         AUDIO_A2DP_STATE_SUSPENDED,
  94         AUDIO_A2DP_STATE_STARTED
  95 };
  96
  97 struct a2dp_stream_out {
  98         struct audio_stream_out stream;
  99
 100         struct audio_endpoint *ep;
 101         enum a2dp_state_t audio_state;
 102 };
 103
 104 struct a2dp_audio_dev {
 105         struct audio_hw_device dev;
 106         struct a2dp_stream_out *out;
 107 };
 108
 109 static const a2dp_sbc_t sbc_presets[] = {
 110         {
 111                 .frequency = SBC_SAMPLING_FREQ_44100 | SBC_SAMPLING_FREQ_48000,
 112                 .channel_mode = SBC_CHANNEL_MODE_MONO |
 113                                 SBC_CHANNEL_MODE_DUAL_CHANNEL |
 114                                 SBC_CHANNEL_MODE_STEREO |
 115                                 SBC_CHANNEL_MODE_JOINT_STEREO,
 116                 .subbands = SBC_SUBBANDS_4 | SBC_SUBBANDS_8,
 117                 .allocation_method = SBC_ALLOCATION_SNR |
 118                                         SBC_ALLOCATION_LOUDNESS,
 119                 .block_length = SBC_BLOCK_LENGTH_4 | SBC_BLOCK_LENGTH_8 |
 120                                 SBC_BLOCK_LENGTH_12 | SBC_BLOCK_LENGTH_16,
 121                 .min_bitpool = MIN_BITPOOL,
 122                 .max_bitpool = MAX_BITPOOL
 123         },
 124         {
 125                 .frequency = SBC_SAMPLING_FREQ_44100,
 126                 .channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO,
 127                 .subbands = SBC_SUBBANDS_8,
 128                 .allocation_method = SBC_ALLOCATION_LOUDNESS,
 129                 .block_length = SBC_BLOCK_LENGTH_16,
 130                 .min_bitpool = MIN_BITPOOL,
 131                 .max_bitpool = MAX_BITPOOL
 132         },
 133         {
 134                 .frequency = SBC_SAMPLING_FREQ_48000,
 135                 .channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO,
 136                 .subbands = SBC_SUBBANDS_8,
 137                 .allocation_method = SBC_ALLOCATION_LOUDNESS,
 138                 .block_length = SBC_BLOCK_LENGTH_16,
 139                 .min_bitpool = MIN_BITPOOL,
 140                 .max_bitpool = MAX_BITPOOL
 141         },
 142 };
 143
 144 static int sbc_get_presets(struct audio_preset *preset, size_t *len)
 145 {
 146         int i;
 147         int count;
 148         size_t new_len = 0;
 149         uint8_t *ptr = (uint8_t *) preset;
 150         size_t preset_size = sizeof(*preset) + sizeof(a2dp_sbc_t);
 151
 152         DBG("");
 153
 154         count = sizeof(sbc_presets) / sizeof(sbc_presets[0]);
 155
 156         for (i = 0; i < count; i++) {
 157                 preset = (struct audio_preset *) ptr;
 158
 159                 if (new_len + preset_size > *len)
 160                         break;
 161
 162                 preset->len = sizeof(a2dp_sbc_t);
 163                 memcpy(preset->data, &sbc_presets[i], preset->len);
 164
 165                 new_len += preset_size;
 166                 ptr += preset_size;
 167         }
 168
 169         *len = new_len;
 170
 171         return i;
 172 }
 173
 174 static void audio_ipc_cleanup(void)
 175 {
 176         if (audio_sk >= 0) {
 177                 shutdown(audio_sk, SHUT_RDWR);
 178                 audio_sk = -1;
 179         }
 180 }
 181
 182 static int audio_ipc_cmd(uint8_t service_id, uint8_t opcode, uint16_t len,
 183                         void *param, size_t *rsp_len, void *rsp, int *fd)
 184 {
 185         ssize_t ret;
 186         struct msghdr msg;
 187         struct iovec iv[2];
 188         struct hal_hdr cmd;
 189         char cmsgbuf[CMSG_SPACE(sizeof(int))];
 190         struct hal_status s;
 191         size_t s_len = sizeof(s);
 192
 193         if (audio_sk < 0) {
 194                 error("audio: Invalid cmd socket passed to audio_ipc_cmd");
 195                 goto failed;
 196         }
 197
 198         if (!rsp || !rsp_len) {
 199                 memset(&s, 0, s_len);
 200                 rsp_len = &s_len;
 201                 rsp = &s;
 202         }
 203
 204         memset(&msg, 0, sizeof(msg));
 205         memset(&cmd, 0, sizeof(cmd));
 206
 207         cmd.service_id = service_id;
 208         cmd.opcode = opcode;
 209         cmd.len = len;
 210
 211         iv[0].iov_base = &cmd;
 212         iv[0].iov_len = sizeof(cmd);
 213
 214         iv[1].iov_base = param;
 215         iv[1].iov_len = len;
 216
 217         msg.msg_iov = iv;
 218         msg.msg_iovlen = 2;
 219
 220         pthread_mutex_lock(&sk_mutex);
 221
 222         ret = sendmsg(audio_sk, &msg, 0);
 223         if (ret < 0) {
 224                 error("audio: Sending command failed:%s", strerror(errno));
 225                 pthread_mutex_unlock(&sk_mutex);
 226                 goto failed;
 227         }
 228
 229         /* socket was shutdown */
 230         if (ret == 0) {
 231                 error("audio: Command socket closed");
 232                 goto failed;
 233         }
 234
 235         memset(&msg, 0, sizeof(msg));
 236         memset(&cmd, 0, sizeof(cmd));
 237
 238         iv[0].iov_base = &cmd;
 239         iv[0].iov_len = sizeof(cmd);
 240
 241         iv[1].iov_base = rsp;
 242         iv[1].iov_len = *rsp_len;
 243
 244         msg.msg_iov = iv;
 245         msg.msg_iovlen = 2;
 246
 247         if (fd) {
 248                 memset(cmsgbuf, 0, sizeof(cmsgbuf));
 249                 msg.msg_control = cmsgbuf;
 250                 msg.msg_controllen = sizeof(cmsgbuf);
 251         }
 252
 253         ret = recvmsg(audio_sk, &msg, 0);
 254         if (ret < 0) {
 255                 error("audio: Receiving command response failed:%s",
 256                                                         strerror(errno));
 257                 pthread_mutex_unlock(&sk_mutex);
 258                 goto failed;
 259         }
 260
 261         pthread_mutex_unlock(&sk_mutex);
 262
 263         if (ret < (ssize_t) sizeof(cmd)) {
 264                 error("audio: Too small response received(%zd bytes)", ret);
 265                 goto failed;
 266         }
 267
 268         if (cmd.service_id != service_id) {
 269                 error("audio: Invalid service id (%u vs %u)", cmd.service_id,
 270                                                                 service_id);
 271                 goto failed;
 272         }
 273
 274         if (ret != (ssize_t) (sizeof(cmd) + cmd.len)) {
 275                 error("audio: Malformed response received(%zd bytes)", ret);
 276                 goto failed;
 277         }
 278
 279         if (cmd.opcode != opcode && cmd.opcode != AUDIO_OP_STATUS) {
 280                 error("audio: Invalid opcode received (%u vs %u)",
 281                                                 cmd.opcode, opcode);
 282                 goto failed;
 283         }
 284
 285         if (cmd.opcode == AUDIO_OP_STATUS) {
 286                 struct hal_status *s = rsp;
 287
 288                 if (sizeof(*s) != cmd.len) {
 289                         error("audio: Invalid status length");
 290                         goto failed;
 291                 }
 292
 293                 if (s->code == AUDIO_STATUS_SUCCESS) {
 294                         error("audio: Invalid success status response");
 295                         goto failed;
 296                 }
 297
 298                 return s->code;
 299         }
 300
 301         /* Receive auxiliary data in msg */
 302         if (fd) {
 303                 struct cmsghdr *cmsg;
 304
 305                 *fd = -1;
 306
 307                 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg;
 308                                         cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 309                         if (cmsg->cmsg_level == SOL_SOCKET
 310                                         && cmsg->cmsg_type == SCM_RIGHTS) {
 311                                 memcpy(fd, CMSG_DATA(cmsg), sizeof(int));
 312                                 break;
 313                         }
 314                 }
 315         }
 316
 317         if (rsp_len)
 318                 *rsp_len = cmd.len;
 319
 320         return AUDIO_STATUS_SUCCESS;
 321
 322 failed:
 323         /* Some serious issue happen on IPC - recover */
 324         shutdown(audio_sk, SHUT_RDWR);
 325         audio_sk = -1;
 326         return AUDIO_STATUS_FAILED;
 327 }
 328
 329 static int ipc_open_cmd(const struct audio_codec *codec)
 330 {
 331         uint8_t buf[BLUEZ_AUDIO_MTU];
 332         struct audio_cmd_open *cmd = (struct audio_cmd_open *) buf;
 333         struct audio_rsp_open rsp;
 334         size_t cmd_len = sizeof(buf) - sizeof(*cmd);
 335         size_t rsp_len = sizeof(rsp);
 336         int result;
 337
 338         DBG("");
 339
 340         memcpy(cmd->uuid, a2dp_src_uuid, sizeof(a2dp_src_uuid));
 341
 342         cmd->codec = codec->type;
 343         cmd->presets = codec->get_presets(cmd->preset, &cmd_len);
 344
 345         cmd_len += sizeof(*cmd);
 346
 347         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_OPEN, cmd_len, cmd,
 348                                 &rsp_len, &rsp, NULL);
 349
 350         if (result != AUDIO_STATUS_SUCCESS)
 351                 return 0;
 352
 353         return rsp.id;
 354 }
 355
 356 static int ipc_close_cmd(uint8_t endpoint_id)
 357 {
 358         struct audio_cmd_close cmd;
 359         int result;
 360
 361         DBG("");
 362
 363         cmd.id = endpoint_id;
 364
 365         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_CLOSE,
 366                                 sizeof(cmd), &cmd, NULL, NULL, NULL);
 367
 368         return result;
 369 }
 370
 371 static int ipc_open_stream_cmd(uint8_t endpoint_id,
 372                                         struct audio_preset **caps)
 373 {
 374         char buf[BLUEZ_AUDIO_MTU];
 375         struct audio_cmd_open_stream cmd;
 376         struct audio_rsp_open_stream *rsp =
 377                                         (struct audio_rsp_open_stream *) &buf;
 378         size_t rsp_len = sizeof(buf);
 379         int result;
 380
 381         DBG("");
 382
 383         if (!caps)
 384                 return AUDIO_STATUS_FAILED;
 385
 386         cmd.id = endpoint_id;
 387
 388         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_OPEN_STREAM,
 389                                 sizeof(cmd), &cmd, &rsp_len, rsp, NULL);
 390
 391         if (result == AUDIO_STATUS_SUCCESS) {
 392                 size_t buf_len = sizeof(struct audio_preset) +
 393                                         rsp->preset[0].len;
 394                 *caps = malloc(buf_len);
 395                 memcpy(*caps, &rsp->preset, buf_len);
 396         } else {
 397                 *caps = NULL;
 398         }
 399
 400         return result;
 401 }
 402
 403 static int ipc_close_stream_cmd(uint8_t endpoint_id)
 404 {
 405         struct audio_cmd_close_stream cmd;
 406         int result;
 407
 408         DBG("");
 409
 410         cmd.id = endpoint_id;
 411
 412         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_CLOSE_STREAM,
 413                                 sizeof(cmd), &cmd, NULL, NULL, NULL);
 414
 415         return result;
 416 }
 417
 418 static int ipc_resume_stream_cmd(uint8_t endpoint_id)
 419 {
 420         struct audio_cmd_resume_stream cmd;
 421         int result;
 422
 423         DBG("");
 424
 425         cmd.id = endpoint_id;
 426
 427         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_RESUME_STREAM,
 428                                 sizeof(cmd), &cmd, NULL, NULL, NULL);
 429
 430         return result;
 431 }
 432
 433 static int ipc_suspend_stream_cmd(uint8_t endpoint_id)
 434 {
 435         struct audio_cmd_suspend_stream cmd;
 436         int result;
 437
 438         DBG("");
 439
 440         cmd.id = endpoint_id;
 441
 442         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_SUSPEND_STREAM,
 443                                 sizeof(cmd), &cmd, NULL, NULL, NULL);
 444
 445         return result;
 446 }
 447
 448 static int register_endpoints(void)
 449 {
 450         struct audio_endpoint *ep = &audio_endpoints[0];
 451         size_t i;
 452
 453         for (i = 0; i < NUM_CODECS; i++, ep++) {
 454                 const struct audio_codec *codec = &audio_codecs[i];
 455
 456                 ep->id = ipc_open_cmd(codec);
 457
 458                 if (!ep->id)
 459                         return AUDIO_STATUS_FAILED;
 460
 461                 ep->codec = codec;
 462                 ep->codec_data = NULL;
 463                 ep->fd = -1;
 464         }
 465
 466         return AUDIO_STATUS_SUCCESS;
 467 }
 468
 469 static void unregister_endpoints(void)
 470 {
 471         size_t i;
 472
 473         for (i = 0; i < MAX_AUDIO_ENDPOINTS; i++) {
 474                 struct audio_endpoint *ep = &audio_endpoints[i];
 475
 476                 if (ep->id) {
 477                         ipc_close_cmd(ep->id);
 478                         memset(ep, 0, sizeof(*ep));
 479                 }
 480         }
 481 }
 482
 483 static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
 484                                                                 size_t bytes)
 485 {
 486         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
 487
 488         /* We can auto-start only from standby */
 489         if (out->audio_state == AUDIO_A2DP_STATE_STANDBY) {
 490                 DBG("stream in standby, auto-start");
 491
 492                 if (ipc_resume_stream_cmd(out->ep->id) != AUDIO_STATUS_SUCCESS)
 493                         return -1;
 494
 495                 out->audio_state = AUDIO_A2DP_STATE_STARTED;
 496         }
 497
 498         if (out->audio_state != AUDIO_A2DP_STATE_STARTED) {
 499                 DBG("stream not started");
 500                 return -1;
 501         }
 502
 503         /* TODO: encode data using codec */
 504
 505         return bytes;
 506 }
 507
 508 static uint32_t out_get_sample_rate(const struct audio_stream *stream)
 509 {
 510         DBG("");
 511         return -ENOSYS;
 512 }
 513
 514 static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
 515 {
 516         DBG("");
 517         return -ENOSYS;
 518 }
 519
 520 static size_t out_get_buffer_size(const struct audio_stream *stream)
 521 {
 522         DBG("");
 523         return -ENOSYS;
 524 }
 525
 526 static uint32_t out_get_channels(const struct audio_stream *stream)
 527 {
 528         DBG("");
 529         return -ENOSYS;
 530 }
 531
 532 static audio_format_t out_get_format(const struct audio_stream *stream)
 533 {
 534         DBG("");
 535         return -ENOSYS;
 536 }
 537
 538 static int out_set_format(struct audio_stream *stream, audio_format_t format)
 539 {
 540         DBG("");
 541         return -ENOSYS;
 542 }
 543
 544 static int out_standby(struct audio_stream *stream)
 545 {
 546         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
 547
 548         DBG("");
 549
 550         if (out->audio_state == AUDIO_A2DP_STATE_STARTED) {
 551                 if (ipc_suspend_stream_cmd(out->ep->id) != AUDIO_STATUS_SUCCESS)
 552                         return -1;
 553                 out->audio_state = AUDIO_A2DP_STATE_STANDBY;
 554         }
 555
 556         return 0;
 557 }
 558
 559 static int out_dump(const struct audio_stream *stream, int fd)
 560 {
 561         DBG("");
 562         return -ENOSYS;
 563 }
 564
 565 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
 566 {
 567         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
 568         char *kvpair;
 569         char *str;
 570         char *saveptr;
 571         bool enter_suspend = false;
 572         bool exit_suspend = false;
 573
 574         DBG("%s", kvpairs);
 575
 576         str = strdup(kvpairs);
 577         kvpair = strtok_r(str, ";", &saveptr);
 578
 579         for (; kvpair && *kvpair; kvpair = strtok_r(NULL, ";", &saveptr)) {
 580                 char *keyval;
 581
 582                 keyval = strchr(kvpair, '=');
 583                 if (!keyval)
 584                         continue;
 585
 586                 *keyval = '\0';
 587                 keyval++;
 588
 589                 if (!strcmp(kvpair, "closing")) {
 590                         if (!strcmp(keyval, "true"))
 591                                 out->audio_state = AUDIO_A2DP_STATE_NONE;
 592                 } else if (!strcmp(kvpair, "A2dpSuspended")) {
 593                         if (!strcmp(keyval, "true"))
 594                                 enter_suspend = true;
 595                         else
 596                                 exit_suspend = true;
 597                 }
 598         }
 599
 600         free(str);
 601
 602         if (enter_suspend && out->audio_state == AUDIO_A2DP_STATE_STARTED) {
 603                 if (ipc_suspend_stream_cmd(out->ep->id) != AUDIO_STATUS_SUCCESS)
 604                         return -1;
 605                 out->audio_state = AUDIO_A2DP_STATE_SUSPENDED;
 606         }
 607
 608         if (exit_suspend && out->audio_state == AUDIO_A2DP_STATE_SUSPENDED)
 609                 out->audio_state = AUDIO_A2DP_STATE_STANDBY;
 610
 611         return 0;
 612 }
 613
 614 static char *out_get_parameters(const struct audio_stream *stream,
 615                                                         const char *keys)
 616 {
 617         DBG("");
 618         return strdup("");
 619 }
 620
 621 static uint32_t out_get_latency(const struct audio_stream_out *stream)
 622 {
 623         DBG("");
 624         return -ENOSYS;
 625 }
 626
 627 static int out_set_volume(struct audio_stream_out *stream, float left,
 628                                                                 float right)
 629 {
 630         DBG("");
 631         /* volume controlled in audioflinger mixer (digital) */
 632         return -ENOSYS;
 633 }
 634
 635 static int out_get_render_position(const struct audio_stream_out *stream,
 636                                                         uint32_t *dsp_frames)
 637 {
 638         DBG("");
 639         return -ENOSYS;
 640 }
 641
 642 static int out_add_audio_effect(const struct audio_stream *stream,
 643                                                         effect_handle_t effect)
 644 {
 645         DBG("");
 646         return -ENOSYS;
 647 }
 648
 649 static int out_remove_audio_effect(const struct audio_stream *stream,
 650                                                         effect_handle_t effect)
 651 {
 652         DBG("");
 653         return -ENOSYS;
 654 }
 655
 656 static uint32_t in_get_sample_rate(const struct audio_stream *stream)
 657 {
 658         DBG("");
 659         return -ENOSYS;
 660 }
 661
 662 static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
 663 {
 664         DBG("");
 665         return -ENOSYS;
 666 }
 667
 668 static size_t in_get_buffer_size(const struct audio_stream *stream)
 669 {
 670         DBG("");
 671         return -ENOSYS;
 672 }
 673
 674 static uint32_t in_get_channels(const struct audio_stream *stream)
 675 {
 676         DBG("");
 677         return -ENOSYS;
 678 }
 679
 680 static audio_format_t in_get_format(const struct audio_stream *stream)
 681 {
 682         DBG("");
 683         return -ENOSYS;
 684 }
 685
 686 static int in_set_format(struct audio_stream *stream, audio_format_t format)
 687 {
 688         DBG("");
 689         return -ENOSYS;
 690 }
 691
 692 static int in_standby(struct audio_stream *stream)
 693 {
 694         DBG("");
 695         return -ENOSYS;
 696 }
 697
 698 static int in_dump(const struct audio_stream *stream, int fd)
 699 {
 700         DBG("");
 701         return -ENOSYS;
 702 }
 703
 704 static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
 705 {
 706         DBG("");
 707         return -ENOSYS;
 708 }
 709
 710 static char *in_get_parameters(const struct audio_stream *stream,
 711                                                         const char *keys)
 712 {
 713         DBG("");
 714         return strdup("");
 715 }
 716
 717 static int in_set_gain(struct audio_stream_in *stream, float gain)
 718 {
 719         DBG("");
 720         return -ENOSYS;
 721 }
 722
 723 static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
 724                                                                 size_t bytes)
 725 {
 726         DBG("");
 727         return -ENOSYS;
 728 }
 729
 730 static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
 731 {
 732         DBG("");
 733         return -ENOSYS;
 734 }
 735
 736 static int in_add_audio_effect(const struct audio_stream *stream,
 737                                                         effect_handle_t effect)
 738 {
 739         DBG("");
 740         return -ENOSYS;
 741 }
 742
 743 static int in_remove_audio_effect(const struct audio_stream *stream,
 744                                                         effect_handle_t effect)
 745 {
 746         DBG("");
 747         return -ENOSYS;
 748 }
 749
 750 static int audio_open_output_stream(struct audio_hw_device *dev,
 751                                         audio_io_handle_t handle,
 752                                         audio_devices_t devices,
 753                                         audio_output_flags_t flags,
 754                                         struct audio_config *config,
 755                                         struct audio_stream_out **stream_out)
 756
 757 {
 758         struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *) dev;
 759         struct a2dp_stream_out *out;
 760         struct audio_preset *preset;
 761
 762         out = calloc(1, sizeof(struct a2dp_stream_out));
 763         if (!out)
 764                 return -ENOMEM;
 765
 766         DBG("");
 767
 768         out->stream.common.get_sample_rate = out_get_sample_rate;
 769         out->stream.common.set_sample_rate = out_set_sample_rate;
 770         out->stream.common.get_buffer_size = out_get_buffer_size;
 771         out->stream.common.get_channels = out_get_channels;
 772         out->stream.common.get_format = out_get_format;
 773         out->stream.common.set_format = out_set_format;
 774         out->stream.common.standby = out_standby;
 775         out->stream.common.dump = out_dump;
 776         out->stream.common.set_parameters = out_set_parameters;
 777         out->stream.common.get_parameters = out_get_parameters;
 778         out->stream.common.add_audio_effect = out_add_audio_effect;
 779         out->stream.common.remove_audio_effect = out_remove_audio_effect;
 780         out->stream.get_latency = out_get_latency;
 781         out->stream.set_volume = out_set_volume;
 782         out->stream.write = out_write;
 783         out->stream.get_render_position = out_get_render_position;
 784
 785         /* TODO: for now we always use endpoint 0 */
 786         out->ep = &audio_endpoints[0];
 787
 788         if (ipc_open_stream_cmd(out->ep->id, &preset) != AUDIO_STATUS_SUCCESS)
 789                 goto fail;
 790
 791         if (!preset)
 792                 goto fail;
 793
 794         /* TODO: initialize codec using received audio_preset */
 795
 796         free(preset);
 797
 798         *stream_out = &out->stream;
 799         a2dp_dev->out = out;
 800
 801         out->audio_state = AUDIO_A2DP_STATE_STANDBY;
 802
 803         return 0;
 804
 805 fail:
 806         free(out);
 807         *stream_out = NULL;
 808         return -EIO;
 809 }
 810
 811 static void audio_close_output_stream(struct audio_hw_device *dev,
 812                                         struct audio_stream_out *stream)
 813 {
 814         struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *) dev;
 815         struct audio_endpoint *ep = a2dp_dev->out->ep;
 816
 817         DBG("");
 818
 819         ipc_close_stream_cmd(ep->id);
 820
 821         /* TODO: cleanup codec */
 822
 823         free(stream);
 824         a2dp_dev->out = NULL;
 825 }
 826
 827 static int audio_set_parameters(struct audio_hw_device *dev,
 828                                                         const char *kvpairs)
 829 {
 830         DBG("");
 831         return -ENOSYS;
 832 }
 833
 834 static char *audio_get_parameters(const struct audio_hw_device *dev,
 835                                                         const char *keys)
 836 {
 837         DBG("");
 838         return strdup("");
 839 }
 840
 841 static int audio_init_check(const struct audio_hw_device *dev)
 842 {
 843         DBG("");
 844         return -ENOSYS;
 845 }
 846
 847 static int audio_set_voice_volume(struct audio_hw_device *dev, float volume)
 848 {
 849         DBG("");
 850         return -ENOSYS;
 851 }
 852
 853 static int audio_set_master_volume(struct audio_hw_device *dev, float volume)
 854 {
 855         DBG("");
 856         return -ENOSYS;
 857 }
 858
 859 static int audio_set_mode(struct audio_hw_device *dev, int mode)
 860 {
 861         DBG("");
 862         return -ENOSYS;
 863 }
 864
 865 static int audio_set_mic_mute(struct audio_hw_device *dev, bool state)
 866 {
 867         DBG("");
 868         return -ENOSYS;
 869 }
 870
 871 static int audio_get_mic_mute(const struct audio_hw_device *dev, bool *state)
 872 {
 873         DBG("");
 874         return -ENOSYS;
 875 }
 876
 877 static size_t audio_get_input_buffer_size(const struct audio_hw_device *dev,
 878                                         const struct audio_config *config)
 879 {
 880         DBG("");
 881         return -ENOSYS;
 882 }
 883
 884 static int audio_open_input_stream(struct audio_hw_device *dev,
 885                                         audio_io_handle_t handle,
 886                                         audio_devices_t devices,
 887                                         struct audio_config *config,
 888                                         struct audio_stream_in **stream_in)
 889 {
 890         struct audio_stream_in *in;
 891
 892         DBG("");
 893
 894         in = calloc(1, sizeof(struct audio_stream_in));
 895         if (!in)
 896                 return -ENOMEM;
 897
 898         in->common.get_sample_rate = in_get_sample_rate;
 899         in->common.set_sample_rate = in_set_sample_rate;
 900         in->common.get_buffer_size = in_get_buffer_size;
 901         in->common.get_channels = in_get_channels;
 902         in->common.get_format = in_get_format;
 903         in->common.set_format = in_set_format;
 904         in->common.standby = in_standby;
 905         in->common.dump = in_dump;
 906         in->common.set_parameters = in_set_parameters;
 907         in->common.get_parameters = in_get_parameters;
 908         in->common.add_audio_effect = in_add_audio_effect;
 909         in->common.remove_audio_effect = in_remove_audio_effect;
 910         in->set_gain = in_set_gain;
 911         in->read = in_read;
 912         in->get_input_frames_lost = in_get_input_frames_lost;
 913
 914         *stream_in = in;
 915
 916         return 0;
 917 }
 918
 919 static void audio_close_input_stream(struct audio_hw_device *dev,
 920                                         struct audio_stream_in *stream_in)
 921 {
 922         DBG("");
 923         free(stream_in);
 924 }
 925
 926 static int audio_dump(const audio_hw_device_t *device, int fd)
 927 {
 928         DBG("");
 929         return -ENOSYS;
 930 }
 931
 932 static int audio_close(hw_device_t *device)
 933 {
 934         struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *)device;
 935
 936         DBG("");
 937
 938         pthread_mutex_lock(&close_mutex);
 939         audio_ipc_cleanup();
 940         close_thread = true;
 941         pthread_mutex_unlock(&close_mutex);
 942
 943         pthread_join(ipc_th, NULL);
 944
 945         close(listen_sk);
 946         listen_sk = -1;
 947
 948         free(a2dp_dev);
 949         return 0;
 950 }
 951
 952 static void *ipc_handler(void *data)
 953 {
 954         bool done = false;
 955         struct pollfd pfd;
 956
 957         DBG("");
 958
 959         while (!done) {
 960                 DBG("Waiting for connection ...");
 961                 audio_sk = accept(listen_sk, NULL, NULL);
 962                 if (audio_sk < 0) {
 963                         int err = errno;
 964                         error("audio: Failed to accept socket: %d (%s)", err,
 965                                                                 strerror(err));
 966                         continue;
 967                 }
 968
 969                 DBG("Audio IPC: Connected");
 970
 971                 if (register_endpoints() != AUDIO_STATUS_SUCCESS) {
 972                         error("audio: Failed to register endpoints");
 973
 974                         unregister_endpoints();
 975
 976                         shutdown(audio_sk, SHUT_RDWR);
 977                         continue;
 978                 }
 979
 980                 memset(&pfd, 0, sizeof(pfd));
 981                 pfd.fd = audio_sk;
 982                 pfd.events = POLLHUP | POLLERR | POLLNVAL;
 983
 984                 /* Check if socket is still alive. Empty while loop.*/
 985                 while (poll(&pfd, 1, -1) < 0 && errno == EINTR);
 986
 987                 if (pfd.revents & (POLLHUP | POLLERR | POLLNVAL)) {
 988                         info("Audio HAL: Socket closed");
 989                         audio_sk = -1;
 990                 }
 991
 992                 /*Check if audio_dev is closed */
 993                 pthread_mutex_lock(&close_mutex);
 994                 done = close_thread;
 995                 close_thread = false;
 996                 pthread_mutex_unlock(&close_mutex);
 997         }
 998
 999         unregister_endpoints();
1000
1001         info("Closing Audio IPC thread");
1002         return NULL;
1003 }
1004
1005 static int audio_ipc_init(void)
1006 {
1007         struct sockaddr_un addr;
1008         int err;
1009         int sk;
1010
1011         DBG("");
1012
1013         sk = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
1014         if (sk < 0) {
1015                 err = errno;
1016                 error("audio: Failed to create socket: %d (%s)", err,
1017                                                                 strerror(err));
1018                 return err;
1019         }
1020
1021         memset(&addr, 0, sizeof(addr));
1022         addr.sun_family = AF_UNIX;
1023
1024         memcpy(addr.sun_path, BLUEZ_AUDIO_SK_PATH,
1025                                         sizeof(BLUEZ_AUDIO_SK_PATH));
1026
1027         if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1028                 err = errno;
1029                 error("audio: Failed to bind socket: %d (%s)", err,
1030                                                                 strerror(err));
1031                 goto failed;
1032         }
1033
1034         if (listen(sk, 1) < 0) {
1035                 err = errno;
1036                 error("audio: Failed to listen on the socket: %d (%s)", err,
1037                                                                 strerror(err));
1038                 goto failed;
1039         }
1040
1041         listen_sk = sk;
1042
1043         err = pthread_create(&ipc_th, NULL, ipc_handler, NULL);
1044         if (err) {
1045                 err = -err;
1046                 ipc_th = 0;
1047                 error("audio: Failed to start Audio IPC thread: %d (%s)",
1048                                                         err, strerror(err));
1049                 goto failed;
1050         }
1051
1052         return 0;
1053
1054 failed:
1055         close(sk);
1056         return err;
1057 }
1058
1059 static int audio_open(const hw_module_t *module, const char *name,
1060                                                         hw_device_t **device)
1061 {
1062         struct a2dp_audio_dev *a2dp_dev;
1063         int err;
1064
1065         DBG("");
1066
1067         if (strcmp(name, AUDIO_HARDWARE_INTERFACE)) {
1068                 error("audio: interface %s not matching [%s]", name,
1069                                                 AUDIO_HARDWARE_INTERFACE);
1070                 return -EINVAL;
1071         }
1072
1073         err = audio_ipc_init();
1074         if (err)
1075                 return -err;
1076
1077         a2dp_dev = calloc(1, sizeof(struct a2dp_audio_dev));
1078         if (!a2dp_dev)
1079                 return -ENOMEM;
1080
1081         a2dp_dev->dev.common.version = AUDIO_DEVICE_API_VERSION_CURRENT;
1082         a2dp_dev->dev.common.module = (struct hw_module_t *) module;
1083         a2dp_dev->dev.common.close = audio_close;
1084
1085         a2dp_dev->dev.init_check = audio_init_check;
1086         a2dp_dev->dev.set_voice_volume = audio_set_voice_volume;
1087         a2dp_dev->dev.set_master_volume = audio_set_master_volume;
1088         a2dp_dev->dev.set_mode = audio_set_mode;
1089         a2dp_dev->dev.set_mic_mute = audio_set_mic_mute;
1090         a2dp_dev->dev.get_mic_mute = audio_get_mic_mute;
1091         a2dp_dev->dev.set_parameters = audio_set_parameters;
1092         a2dp_dev->dev.get_parameters = audio_get_parameters;
1093         a2dp_dev->dev.get_input_buffer_size = audio_get_input_buffer_size;
1094         a2dp_dev->dev.open_output_stream = audio_open_output_stream;
1095         a2dp_dev->dev.close_output_stream = audio_close_output_stream;
1096         a2dp_dev->dev.open_input_stream = audio_open_input_stream;
1097         a2dp_dev->dev.close_input_stream = audio_close_input_stream;
1098         a2dp_dev->dev.dump = audio_dump;
1099
1100         /* Note that &a2dp_dev->dev.common is the same pointer as a2dp_dev.
1101          * This results from the structure of following structs:a2dp_audio_dev,
1102          * audio_hw_device. We will rely on this later in the code.*/
1103         *device = &a2dp_dev->dev.common;
1104
1105         return 0;
1106 }
1107
1108 static struct hw_module_methods_t hal_module_methods = {
1109         .open = audio_open,
1110 };
1111
1112 struct audio_module HAL_MODULE_INFO_SYM = {
1113         .common = {
1114         .tag = HARDWARE_MODULE_TAG,
1115         .version_major = 1,
1116         .version_minor = 0,
1117         .id = AUDIO_HARDWARE_MODULE_ID,
1118         .name = "A2DP Bluez HW HAL",
1119         .author = "Intel Corporation",
1120         .methods = &hal_module_methods,
1121         },
1122 };