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 #include <arpa/inet.h>
  28
  29 #include <hardware/audio.h>
  30 #include <hardware/hardware.h>
  31
  32 #include <sbc/sbc.h>
  33
  34 #include "audio-msg.h"
  35 #include "hal-log.h"
  36 #include "hal-msg.h"
  37 #include "../profiles/audio/a2dp-codecs.h"
  38
  39 #define FIXED_A2DP_PLAYBACK_LATENCY_MS 25
  40
  41 static const uint8_t a2dp_src_uuid[] = {
  42                 0x00, 0x00, 0x11, 0x0a, 0x00, 0x00, 0x10, 0x00,
  43                 0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb };
  44
  45 static int listen_sk = -1;
  46 static int audio_sk = -1;
  47 static bool close_thread = false;
  48
  49 static pthread_t ipc_th = 0;
  50 static pthread_mutex_t close_mutex = PTHREAD_MUTEX_INITIALIZER;
  51 static pthread_mutex_t sk_mutex = PTHREAD_MUTEX_INITIALIZER;
  52
  53 #if __BYTE_ORDER == __LITTLE_ENDIAN
  54
  55 struct rtp_header {
  56         unsigned cc:4;
  57         unsigned x:1;
  58         unsigned p:1;
  59         unsigned v:2;
  60
  61         unsigned pt:7;
  62         unsigned m:1;
  63
  64         uint16_t sequence_number;
  65         uint32_t timestamp;
  66         uint32_t ssrc;
  67         uint32_t csrc[0];
  68 } __attribute__ ((packed));
  69
  70 struct rtp_payload {
  71         unsigned frame_count:4;
  72         unsigned rfa0:1;
  73         unsigned is_last_fragment:1;
  74         unsigned is_first_fragment:1;
  75         unsigned is_fragmented:1;
  76 } __attribute__ ((packed));
  77
  78 #elif __BYTE_ORDER == __BIG_ENDIAN
  79
  80 struct rtp_header {
  81         unsigned v:2;
  82         unsigned p:1;
  83         unsigned x:1;
  84         unsigned cc:4;
  85
  86         unsigned m:1;
  87         unsigned pt:7;
  88
  89         uint16_t sequence_number;
  90         uint32_t timestamp;
  91         uint32_t ssrc;
  92         uint32_t csrc[0];
  93 } __attribute__ ((packed));
  94
  95 struct rtp_payload {
  96         unsigned is_fragmented:1;
  97         unsigned is_first_fragment:1;
  98         unsigned is_last_fragment:1;
  99         unsigned rfa0:1;
 100         unsigned frame_count:4;
 101 } __attribute__ ((packed));
 102
 103 #else
 104 #error "Unknown byte order"
 105 #endif
 106
 107 struct media_packet {
 108         struct rtp_header hdr;
 109         struct rtp_payload payload;
 110         uint8_t data[0];
 111 };
 112
 113 struct audio_input_config {
 114         uint32_t rate;
 115         uint32_t channels;
 116         audio_format_t format;
 117 };
 118
 119 struct sbc_data {
 120         a2dp_sbc_t sbc;
 121
 122         sbc_t enc;
 123
 124         size_t in_frame_len;
 125         size_t in_buf_size;
 126
 127         size_t out_buf_size;
 128         uint8_t *out_buf;
 129
 130         unsigned frame_duration;
 131         unsigned frames_per_packet;
 132
 133         struct timespec start;
 134         unsigned frames_sent;
 135
 136         uint16_t seq;
 137 };
 138
 139 static inline void timespec_diff(struct timespec *a, struct timespec *b,
 140                                         struct timespec *res)
 141 {
 142         res->tv_sec = a->tv_sec - b->tv_sec;
 143         res->tv_nsec = a->tv_nsec - b->tv_nsec;
 144
 145         if (res->tv_nsec < 0) {
 146                 res->tv_sec--;
 147                 res->tv_nsec += 1000000000; /* 1sec */
 148         }
 149 }
 150
 151 static int sbc_get_presets(struct audio_preset *preset, size_t *len);
 152 static int sbc_codec_init(struct audio_preset *preset, uint16_t mtu,
 153                                 void **codec_data);
 154 static int sbc_cleanup(void *codec_data);
 155 static int sbc_get_config(void *codec_data, struct audio_input_config *config);
 156 static size_t sbc_get_buffer_size(void *codec_data);
 157 static size_t sbc_get_mediapacket_duration(void *codec_data);
 158 static void sbc_resume(void *codec_data);
 159 static ssize_t sbc_write_data(void *codec_data, const void *buffer,
 160                                         size_t bytes, int fd);
 161
 162 struct audio_codec {
 163         uint8_t type;
 164
 165         int (*get_presets) (struct audio_preset *preset, size_t *len);
 166
 167         int (*init) (struct audio_preset *preset, uint16_t mtu,
 168                                 void **codec_data);
 169         int (*cleanup) (void *codec_data);
 170         int (*get_config) (void *codec_data,
 171                                         struct audio_input_config *config);
 172         size_t (*get_buffer_size) (void *codec_data);
 173         size_t (*get_mediapacket_duration) (void *codec_data);
 174         void (*resume) (void *codec_data);
 175         ssize_t (*write_data) (void *codec_data, const void *buffer,
 176                                 size_t bytes, int fd);
 177 };
 178
 179 static const struct audio_codec audio_codecs[] = {
 180         {
 181                 .type = A2DP_CODEC_SBC,
 182
 183                 .get_presets = sbc_get_presets,
 184
 185                 .init = sbc_codec_init,
 186                 .cleanup = sbc_cleanup,
 187                 .get_config = sbc_get_config,
 188                 .get_buffer_size = sbc_get_buffer_size,
 189                 .get_mediapacket_duration = sbc_get_mediapacket_duration,
 190                 .resume = sbc_resume,
 191                 .write_data = sbc_write_data,
 192         }
 193 };
 194
 195 #define NUM_CODECS (sizeof(audio_codecs) / sizeof(audio_codecs[0]))
 196
 197 #define MAX_AUDIO_ENDPOINTS NUM_CODECS
 198
 199 struct audio_endpoint {
 200         uint8_t id;
 201         const struct audio_codec *codec;
 202         void *codec_data;
 203         int fd;
 204 };
 205
 206 static struct audio_endpoint audio_endpoints[MAX_AUDIO_ENDPOINTS];
 207
 208 enum a2dp_state_t {
 209         AUDIO_A2DP_STATE_NONE,
 210         AUDIO_A2DP_STATE_STANDBY,
 211         AUDIO_A2DP_STATE_SUSPENDED,
 212         AUDIO_A2DP_STATE_STARTED
 213 };
 214
 215 struct a2dp_stream_out {
 216         struct audio_stream_out stream;
 217
 218         struct audio_endpoint *ep;
 219         enum a2dp_state_t audio_state;
 220         struct audio_input_config cfg;
 221 };
 222
 223 struct a2dp_audio_dev {
 224         struct audio_hw_device dev;
 225         struct a2dp_stream_out *out;
 226 };
 227
 228 static const a2dp_sbc_t sbc_presets[] = {
 229         {
 230                 .frequency = SBC_SAMPLING_FREQ_44100 | SBC_SAMPLING_FREQ_48000,
 231                 .channel_mode = SBC_CHANNEL_MODE_MONO |
 232                                 SBC_CHANNEL_MODE_DUAL_CHANNEL |
 233                                 SBC_CHANNEL_MODE_STEREO |
 234                                 SBC_CHANNEL_MODE_JOINT_STEREO,
 235                 .subbands = SBC_SUBBANDS_4 | SBC_SUBBANDS_8,
 236                 .allocation_method = SBC_ALLOCATION_SNR |
 237                                         SBC_ALLOCATION_LOUDNESS,
 238                 .block_length = SBC_BLOCK_LENGTH_4 | SBC_BLOCK_LENGTH_8 |
 239                                 SBC_BLOCK_LENGTH_12 | SBC_BLOCK_LENGTH_16,
 240                 .min_bitpool = MIN_BITPOOL,
 241                 .max_bitpool = MAX_BITPOOL
 242         },
 243         {
 244                 .frequency = SBC_SAMPLING_FREQ_44100,
 245                 .channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO,
 246                 .subbands = SBC_SUBBANDS_8,
 247                 .allocation_method = SBC_ALLOCATION_LOUDNESS,
 248                 .block_length = SBC_BLOCK_LENGTH_16,
 249                 .min_bitpool = MIN_BITPOOL,
 250                 .max_bitpool = MAX_BITPOOL
 251         },
 252         {
 253                 .frequency = SBC_SAMPLING_FREQ_48000,
 254                 .channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO,
 255                 .subbands = SBC_SUBBANDS_8,
 256                 .allocation_method = SBC_ALLOCATION_LOUDNESS,
 257                 .block_length = SBC_BLOCK_LENGTH_16,
 258                 .min_bitpool = MIN_BITPOOL,
 259                 .max_bitpool = MAX_BITPOOL
 260         },
 261 };
 262
 263 static int sbc_get_presets(struct audio_preset *preset, size_t *len)
 264 {
 265         int i;
 266         int count;
 267         size_t new_len = 0;
 268         uint8_t *ptr = (uint8_t *) preset;
 269         size_t preset_size = sizeof(*preset) + sizeof(a2dp_sbc_t);
 270
 271         DBG("");
 272
 273         count = sizeof(sbc_presets) / sizeof(sbc_presets[0]);
 274
 275         for (i = 0; i < count; i++) {
 276                 preset = (struct audio_preset *) ptr;
 277
 278                 if (new_len + preset_size > *len)
 279                         break;
 280
 281                 preset->len = sizeof(a2dp_sbc_t);
 282                 memcpy(preset->data, &sbc_presets[i], preset->len);
 283
 284                 new_len += preset_size;
 285                 ptr += preset_size;
 286         }
 287
 288         *len = new_len;
 289
 290         return i;
 291 }
 292
 293 static void sbc_init_encoder(struct sbc_data *sbc_data)
 294 {
 295         a2dp_sbc_t *in = &sbc_data->sbc;
 296         sbc_t *out = &sbc_data->enc;
 297
 298         DBG("");
 299
 300         sbc_init_a2dp(out, 0L, in, sizeof(*in));
 301
 302         out->endian = SBC_LE;
 303         out->bitpool = in->max_bitpool;
 304 }
 305
 306 static int sbc_codec_init(struct audio_preset *preset, uint16_t mtu,
 307                                 void **codec_data)
 308 {
 309         struct sbc_data *sbc_data;
 310         size_t hdr_len = sizeof(struct media_packet);
 311         size_t in_frame_len;
 312         size_t out_frame_len;
 313         size_t num_frames;
 314
 315         DBG("");
 316
 317         if (preset->len != sizeof(a2dp_sbc_t)) {
 318                 DBG("preset size mismatch");
 319                 return AUDIO_STATUS_FAILED;
 320         }
 321
 322         sbc_data = calloc(sizeof(struct sbc_data), 1);
 323
 324         memcpy(&sbc_data->sbc, preset->data, preset->len);
 325
 326         sbc_init_encoder(sbc_data);
 327
 328         in_frame_len = sbc_get_codesize(&sbc_data->enc);
 329         out_frame_len = sbc_get_frame_length(&sbc_data->enc);
 330         num_frames = (mtu - hdr_len) / out_frame_len;
 331
 332         sbc_data->in_frame_len = in_frame_len;
 333         sbc_data->in_buf_size = num_frames * in_frame_len;
 334
 335         sbc_data->out_buf_size = hdr_len + num_frames * out_frame_len;
 336         sbc_data->out_buf = calloc(1, sbc_data->out_buf_size);
 337
 338         sbc_data->frame_duration = sbc_get_frame_duration(&sbc_data->enc);
 339         sbc_data->frames_per_packet = num_frames;
 340
 341         *codec_data = sbc_data;
 342
 343         return AUDIO_STATUS_SUCCESS;
 344 }
 345
 346 static int sbc_cleanup(void *codec_data)
 347 {
 348         struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
 349
 350         DBG("");
 351
 352         sbc_finish(&sbc_data->enc);
 353         free(sbc_data->out_buf);
 354         free(codec_data);
 355
 356         return AUDIO_STATUS_SUCCESS;
 357 }
 358
 359 static int sbc_get_config(void *codec_data, struct audio_input_config *config)
 360 {
 361         struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
 362
 363         switch (sbc_data->sbc.frequency) {
 364         case SBC_SAMPLING_FREQ_16000:
 365                 config->rate = 16000;
 366                 break;
 367         case SBC_SAMPLING_FREQ_32000:
 368                 config->rate = 32000;
 369                 break;
 370         case SBC_SAMPLING_FREQ_44100:
 371                 config->rate = 44100;
 372                 break;
 373         case SBC_SAMPLING_FREQ_48000:
 374                 config->rate = 48000;
 375                 break;
 376         default:
 377                 return AUDIO_STATUS_FAILED;
 378         }
 379         config->channels = sbc_data->sbc.channel_mode == SBC_CHANNEL_MODE_MONO ?
 380                                 AUDIO_CHANNEL_OUT_MONO :
 381                                 AUDIO_CHANNEL_OUT_STEREO;
 382         config->format = AUDIO_FORMAT_PCM_16_BIT;
 383
 384         return AUDIO_STATUS_SUCCESS;
 385 }
 386
 387 static size_t sbc_get_buffer_size(void *codec_data)
 388 {
 389         struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
 390
 391         DBG("");
 392
 393         return sbc_data->in_buf_size;
 394 }
 395
 396 static size_t sbc_get_mediapacket_duration(void *codec_data)
 397 {
 398         struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
 399
 400         DBG("");
 401
 402         return sbc_data->frame_duration * sbc_data->frames_per_packet;
 403 }
 404
 405 static void sbc_resume(void *codec_data)
 406 {
 407         struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
 408
 409         DBG("");
 410
 411         clock_gettime(CLOCK_MONOTONIC, &sbc_data->start);
 412
 413         sbc_data->frames_sent = 0;
 414 }
 415
 416 static ssize_t sbc_write_data(void *codec_data, const void *buffer,
 417                                 size_t bytes, int fd)
 418 {
 419         struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
 420         size_t consumed = 0;
 421         size_t encoded = 0;
 422         struct media_packet *mp = (struct media_packet *) sbc_data->out_buf;
 423         size_t free_space = sbc_data->out_buf_size - sizeof(*mp);
 424         struct timespec cur;
 425         struct timespec diff;
 426         unsigned expected_frames;
 427         int ret;
 428
 429         mp->hdr.v = 2;
 430         mp->hdr.pt = 1;
 431         mp->hdr.sequence_number = htons(sbc_data->seq++);
 432         mp->hdr.ssrc = htonl(1);
 433         mp->payload.frame_count = 0;
 434
 435         while (bytes - consumed >= sbc_data->in_frame_len) {
 436                 ssize_t written = 0;
 437
 438                 ret = sbc_encode(&sbc_data->enc, buffer + consumed,
 439                                         sbc_data->in_frame_len,
 440                                         mp->data + encoded, free_space,
 441                                         &written);
 442
 443                 if (ret < 0) {
 444                         DBG("failed to encode block");
 445                         break;
 446                 }
 447
 448                 mp->payload.frame_count++;
 449
 450                 consumed += ret;
 451                 encoded += written;
 452                 free_space -= written;
 453         }
 454
 455         ret = write(fd, mp, sizeof(*mp) + encoded);
 456         if (ret < 0) {
 457                 int err = errno;
 458                 DBG("error writing data: %d (%s)", err, strerror(err));
 459         }
 460
 461         if (consumed != bytes || free_space != 0) {
 462                 /* we should encode all input data and fill output buffer
 463                  * if we did not, something went wrong but we can't really
 464                  * handle this so this is just sanity check
 465                  */
 466                 DBG("some data were not encoded");
 467         }
 468
 469         sbc_data->frames_sent += mp->payload.frame_count;
 470
 471         clock_gettime(CLOCK_MONOTONIC, &cur);
 472         timespec_diff(&cur, &sbc_data->start, &diff);
 473         expected_frames = (diff.tv_sec * 1000000 + diff.tv_nsec / 1000) /
 474                                 sbc_data->frame_duration;
 475
 476         /* AudioFlinger does not seem to provide any *working* API to provide
 477          * data in some interval and will just send another buffer as soon as
 478          * we process current one. To prevent overflowing L2CAP socket, we need
 479          * to introduce some artificial delay here base on how many audio frames
 480          * were sent so far, i.e. if we're not lagging behind audio stream, we
 481          * can sleep for duration of single media packet.
 482          */
 483         if (sbc_data->frames_sent >= expected_frames)
 484                 usleep(sbc_data->frame_duration * mp->payload.frame_count);
 485
 486         /* we always assume that all data was processed and sent */
 487         return bytes;
 488 }
 489
 490 static void audio_ipc_cleanup(void)
 491 {
 492         if (audio_sk >= 0) {
 493                 shutdown(audio_sk, SHUT_RDWR);
 494                 audio_sk = -1;
 495         }
 496 }
 497
 498 static int audio_ipc_cmd(uint8_t service_id, uint8_t opcode, uint16_t len,
 499                         void *param, size_t *rsp_len, void *rsp, int *fd)
 500 {
 501         ssize_t ret;
 502         struct msghdr msg;
 503         struct iovec iv[2];
 504         struct hal_hdr cmd;
 505         char cmsgbuf[CMSG_SPACE(sizeof(int))];
 506         struct hal_status s;
 507         size_t s_len = sizeof(s);
 508
 509         if (audio_sk < 0) {
 510                 error("audio: Invalid cmd socket passed to audio_ipc_cmd");
 511                 goto failed;
 512         }
 513
 514         if (!rsp || !rsp_len) {
 515                 memset(&s, 0, s_len);
 516                 rsp_len = &s_len;
 517                 rsp = &s;
 518         }
 519
 520         memset(&msg, 0, sizeof(msg));
 521         memset(&cmd, 0, sizeof(cmd));
 522
 523         cmd.service_id = service_id;
 524         cmd.opcode = opcode;
 525         cmd.len = len;
 526
 527         iv[0].iov_base = &cmd;
 528         iv[0].iov_len = sizeof(cmd);
 529
 530         iv[1].iov_base = param;
 531         iv[1].iov_len = len;
 532
 533         msg.msg_iov = iv;
 534         msg.msg_iovlen = 2;
 535
 536         pthread_mutex_lock(&sk_mutex);
 537
 538         ret = sendmsg(audio_sk, &msg, 0);
 539         if (ret < 0) {
 540                 error("audio: Sending command failed:%s", strerror(errno));
 541                 pthread_mutex_unlock(&sk_mutex);
 542                 goto failed;
 543         }
 544
 545         /* socket was shutdown */
 546         if (ret == 0) {
 547                 error("audio: Command socket closed");
 548                 goto failed;
 549         }
 550
 551         memset(&msg, 0, sizeof(msg));
 552         memset(&cmd, 0, sizeof(cmd));
 553
 554         iv[0].iov_base = &cmd;
 555         iv[0].iov_len = sizeof(cmd);
 556
 557         iv[1].iov_base = rsp;
 558         iv[1].iov_len = *rsp_len;
 559
 560         msg.msg_iov = iv;
 561         msg.msg_iovlen = 2;
 562
 563         if (fd) {
 564                 memset(cmsgbuf, 0, sizeof(cmsgbuf));
 565                 msg.msg_control = cmsgbuf;
 566                 msg.msg_controllen = sizeof(cmsgbuf);
 567         }
 568
 569         ret = recvmsg(audio_sk, &msg, 0);
 570         if (ret < 0) {
 571                 error("audio: Receiving command response failed:%s",
 572                                                         strerror(errno));
 573                 pthread_mutex_unlock(&sk_mutex);
 574                 goto failed;
 575         }
 576
 577         pthread_mutex_unlock(&sk_mutex);
 578
 579         if (ret < (ssize_t) sizeof(cmd)) {
 580                 error("audio: Too small response received(%zd bytes)", ret);
 581                 goto failed;
 582         }
 583
 584         if (cmd.service_id != service_id) {
 585                 error("audio: Invalid service id (%u vs %u)", cmd.service_id,
 586                                                                 service_id);
 587                 goto failed;
 588         }
 589
 590         if (ret != (ssize_t) (sizeof(cmd) + cmd.len)) {
 591                 error("audio: Malformed response received(%zd bytes)", ret);
 592                 goto failed;
 593         }
 594
 595         if (cmd.opcode != opcode && cmd.opcode != AUDIO_OP_STATUS) {
 596                 error("audio: Invalid opcode received (%u vs %u)",
 597                                                 cmd.opcode, opcode);
 598                 goto failed;
 599         }
 600
 601         if (cmd.opcode == AUDIO_OP_STATUS) {
 602                 struct hal_status *s = rsp;
 603
 604                 if (sizeof(*s) != cmd.len) {
 605                         error("audio: Invalid status length");
 606                         goto failed;
 607                 }
 608
 609                 if (s->code == AUDIO_STATUS_SUCCESS) {
 610                         error("audio: Invalid success status response");
 611                         goto failed;
 612                 }
 613
 614                 return s->code;
 615         }
 616
 617         /* Receive auxiliary data in msg */
 618         if (fd) {
 619                 struct cmsghdr *cmsg;
 620
 621                 *fd = -1;
 622
 623                 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg;
 624                                         cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 625                         if (cmsg->cmsg_level == SOL_SOCKET
 626                                         && cmsg->cmsg_type == SCM_RIGHTS) {
 627                                 memcpy(fd, CMSG_DATA(cmsg), sizeof(int));
 628                                 break;
 629                         }
 630                 }
 631         }
 632
 633         if (rsp_len)
 634                 *rsp_len = cmd.len;
 635
 636         return AUDIO_STATUS_SUCCESS;
 637
 638 failed:
 639         /* Some serious issue happen on IPC - recover */
 640         shutdown(audio_sk, SHUT_RDWR);
 641         audio_sk = -1;
 642         return AUDIO_STATUS_FAILED;
 643 }
 644
 645 static int ipc_open_cmd(const struct audio_codec *codec)
 646 {
 647         uint8_t buf[BLUEZ_AUDIO_MTU];
 648         struct audio_cmd_open *cmd = (struct audio_cmd_open *) buf;
 649         struct audio_rsp_open rsp;
 650         size_t cmd_len = sizeof(buf) - sizeof(*cmd);
 651         size_t rsp_len = sizeof(rsp);
 652         int result;
 653
 654         DBG("");
 655
 656         memcpy(cmd->uuid, a2dp_src_uuid, sizeof(a2dp_src_uuid));
 657
 658         cmd->codec = codec->type;
 659         cmd->presets = codec->get_presets(cmd->preset, &cmd_len);
 660
 661         cmd_len += sizeof(*cmd);
 662
 663         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_OPEN, cmd_len, cmd,
 664                                 &rsp_len, &rsp, NULL);
 665
 666         if (result != AUDIO_STATUS_SUCCESS)
 667                 return 0;
 668
 669         return rsp.id;
 670 }
 671
 672 static int ipc_close_cmd(uint8_t endpoint_id)
 673 {
 674         struct audio_cmd_close cmd;
 675         int result;
 676
 677         DBG("");
 678
 679         cmd.id = endpoint_id;
 680
 681         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_CLOSE,
 682                                 sizeof(cmd), &cmd, NULL, NULL, NULL);
 683
 684         return result;
 685 }
 686
 687 static int ipc_open_stream_cmd(uint8_t endpoint_id, uint16_t *mtu, int *fd,
 688                                         struct audio_preset **caps)
 689 {
 690         char buf[BLUEZ_AUDIO_MTU];
 691         struct audio_cmd_open_stream cmd;
 692         struct audio_rsp_open_stream *rsp =
 693                                         (struct audio_rsp_open_stream *) &buf;
 694         size_t rsp_len = sizeof(buf);
 695         int result;
 696
 697         DBG("");
 698
 699         if (!caps)
 700                 return AUDIO_STATUS_FAILED;
 701
 702         cmd.id = endpoint_id;
 703
 704         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_OPEN_STREAM,
 705                                 sizeof(cmd), &cmd, &rsp_len, rsp, fd);
 706
 707         if (result == AUDIO_STATUS_SUCCESS) {
 708                 size_t buf_len = sizeof(struct audio_preset) +
 709                                         rsp->preset[0].len;
 710                 *mtu = rsp->mtu;
 711                 *caps = malloc(buf_len);
 712                 memcpy(*caps, &rsp->preset, buf_len);
 713         } else {
 714                 *caps = NULL;
 715         }
 716
 717         return result;
 718 }
 719
 720 static int ipc_close_stream_cmd(uint8_t endpoint_id)
 721 {
 722         struct audio_cmd_close_stream cmd;
 723         int result;
 724
 725         DBG("");
 726
 727         cmd.id = endpoint_id;
 728
 729         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_CLOSE_STREAM,
 730                                 sizeof(cmd), &cmd, NULL, NULL, NULL);
 731
 732         return result;
 733 }
 734
 735 static int ipc_resume_stream_cmd(uint8_t endpoint_id)
 736 {
 737         struct audio_cmd_resume_stream cmd;
 738         int result;
 739
 740         DBG("");
 741
 742         cmd.id = endpoint_id;
 743
 744         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_RESUME_STREAM,
 745                                 sizeof(cmd), &cmd, NULL, NULL, NULL);
 746
 747         return result;
 748 }
 749
 750 static int ipc_suspend_stream_cmd(uint8_t endpoint_id)
 751 {
 752         struct audio_cmd_suspend_stream cmd;
 753         int result;
 754
 755         DBG("");
 756
 757         cmd.id = endpoint_id;
 758
 759         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_SUSPEND_STREAM,
 760                                 sizeof(cmd), &cmd, NULL, NULL, NULL);
 761
 762         return result;
 763 }
 764
 765 static int register_endpoints(void)
 766 {
 767         struct audio_endpoint *ep = &audio_endpoints[0];
 768         size_t i;
 769
 770         for (i = 0; i < NUM_CODECS; i++, ep++) {
 771                 const struct audio_codec *codec = &audio_codecs[i];
 772
 773                 ep->id = ipc_open_cmd(codec);
 774
 775                 if (!ep->id)
 776                         return AUDIO_STATUS_FAILED;
 777
 778                 ep->codec = codec;
 779                 ep->codec_data = NULL;
 780                 ep->fd = -1;
 781         }
 782
 783         return AUDIO_STATUS_SUCCESS;
 784 }
 785
 786 static void unregister_endpoints(void)
 787 {
 788         size_t i;
 789
 790         for (i = 0; i < MAX_AUDIO_ENDPOINTS; i++) {
 791                 struct audio_endpoint *ep = &audio_endpoints[i];
 792
 793                 if (ep->id) {
 794                         ipc_close_cmd(ep->id);
 795                         memset(ep, 0, sizeof(*ep));
 796                 }
 797         }
 798 }
 799
 800 static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
 801                                                                 size_t bytes)
 802 {
 803         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
 804
 805         /* We can auto-start only from standby */
 806         if (out->audio_state == AUDIO_A2DP_STATE_STANDBY) {
 807                 DBG("stream in standby, auto-start");
 808
 809                 if (ipc_resume_stream_cmd(out->ep->id) != AUDIO_STATUS_SUCCESS)
 810                         return -1;
 811
 812                 out->ep->codec->resume(out->ep->codec_data);
 813
 814                 out->audio_state = AUDIO_A2DP_STATE_STARTED;
 815         }
 816
 817         if (out->audio_state != AUDIO_A2DP_STATE_STARTED) {
 818                 DBG("stream not started");
 819                 return -1;
 820         }
 821
 822         if (out->ep->fd < 0) {
 823                 DBG("no transport");
 824                 return -1;
 825         }
 826
 827         return out->ep->codec->write_data(out->ep->codec_data, buffer,
 828                                                 bytes, out->ep->fd);
 829 }
 830
 831 static uint32_t out_get_sample_rate(const struct audio_stream *stream)
 832 {
 833         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
 834
 835         DBG("");
 836
 837         return out->cfg.rate;
 838 }
 839
 840 static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
 841 {
 842         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
 843
 844         DBG("");
 845
 846         if (rate != out->cfg.rate) {
 847                 DBG("cannot set sample rate to %d", rate);
 848                 return -1;
 849         }
 850
 851         return 0;
 852 }
 853
 854 static size_t out_get_buffer_size(const struct audio_stream *stream)
 855 {
 856         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
 857
 858         DBG("");
 859
 860         return out->ep->codec->get_buffer_size(out->ep->codec_data);
 861 }
 862
 863 static uint32_t out_get_channels(const struct audio_stream *stream)
 864 {
 865         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
 866
 867         DBG("");
 868
 869         return out->cfg.channels;
 870 }
 871
 872 static audio_format_t out_get_format(const struct audio_stream *stream)
 873 {
 874         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
 875
 876         DBG("");
 877
 878         return out->cfg.format;
 879 }
 880
 881 static int out_set_format(struct audio_stream *stream, audio_format_t format)
 882 {
 883         DBG("");
 884         return -ENOSYS;
 885 }
 886
 887 static int out_standby(struct audio_stream *stream)
 888 {
 889         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
 890
 891         DBG("");
 892
 893         if (out->audio_state == AUDIO_A2DP_STATE_STARTED) {
 894                 if (ipc_suspend_stream_cmd(out->ep->id) != AUDIO_STATUS_SUCCESS)
 895                         return -1;
 896                 out->audio_state = AUDIO_A2DP_STATE_STANDBY;
 897         }
 898
 899         return 0;
 900 }
 901
 902 static int out_dump(const struct audio_stream *stream, int fd)
 903 {
 904         DBG("");
 905         return -ENOSYS;
 906 }
 907
 908 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
 909 {
 910         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
 911         char *kvpair;
 912         char *str;
 913         char *saveptr;
 914         bool enter_suspend = false;
 915         bool exit_suspend = false;
 916
 917         DBG("%s", kvpairs);
 918
 919         str = strdup(kvpairs);
 920         kvpair = strtok_r(str, ";", &saveptr);
 921
 922         for (; kvpair && *kvpair; kvpair = strtok_r(NULL, ";", &saveptr)) {
 923                 char *keyval;
 924
 925                 keyval = strchr(kvpair, '=');
 926                 if (!keyval)
 927                         continue;
 928
 929                 *keyval = '\0';
 930                 keyval++;
 931
 932                 if (!strcmp(kvpair, "closing")) {
 933                         if (!strcmp(keyval, "true"))
 934                                 out->audio_state = AUDIO_A2DP_STATE_NONE;
 935                 } else if (!strcmp(kvpair, "A2dpSuspended")) {
 936                         if (!strcmp(keyval, "true"))
 937                                 enter_suspend = true;
 938                         else
 939                                 exit_suspend = true;
 940                 }
 941         }
 942
 943         free(str);
 944
 945         if (enter_suspend && out->audio_state == AUDIO_A2DP_STATE_STARTED) {
 946                 if (ipc_suspend_stream_cmd(out->ep->id) != AUDIO_STATUS_SUCCESS)
 947                         return -1;
 948                 out->audio_state = AUDIO_A2DP_STATE_SUSPENDED;
 949         }
 950
 951         if (exit_suspend && out->audio_state == AUDIO_A2DP_STATE_SUSPENDED)
 952                 out->audio_state = AUDIO_A2DP_STATE_STANDBY;
 953
 954         return 0;
 955 }
 956
 957 static char *out_get_parameters(const struct audio_stream *stream,
 958                                                         const char *keys)
 959 {
 960         DBG("");
 961         return strdup("");
 962 }
 963
 964 static uint32_t out_get_latency(const struct audio_stream_out *stream)
 965 {
 966         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
 967         struct audio_endpoint *ep = out->ep;
 968         size_t pkt_duration;
 969
 970         DBG("");
 971
 972         pkt_duration = ep->codec->get_mediapacket_duration(ep->codec_data);
 973
 974         return FIXED_A2DP_PLAYBACK_LATENCY_MS + pkt_duration / 1000;
 975 }
 976
 977 static int out_set_volume(struct audio_stream_out *stream, float left,
 978                                                                 float right)
 979 {
 980         DBG("");
 981         /* volume controlled in audioflinger mixer (digital) */
 982         return -ENOSYS;
 983 }
 984
 985 static int out_get_render_position(const struct audio_stream_out *stream,
 986                                                         uint32_t *dsp_frames)
 987 {
 988         DBG("");
 989         return -ENOSYS;
 990 }
 991
 992 static int out_add_audio_effect(const struct audio_stream *stream,
 993                                                         effect_handle_t effect)
 994 {
 995         DBG("");
 996         return -ENOSYS;
 997 }
 998
 999 static int out_remove_audio_effect(const struct audio_stream *stream,
1000                                                         effect_handle_t effect)
1001 {
1002         DBG("");
1003         return -ENOSYS;
1004 }
1005
1006 static uint32_t in_get_sample_rate(const struct audio_stream *stream)
1007 {
1008         DBG("");
1009         return -ENOSYS;
1010 }
1011
1012 static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
1013 {
1014         DBG("");
1015         return -ENOSYS;
1016 }
1017
1018 static size_t in_get_buffer_size(const struct audio_stream *stream)
1019 {
1020         DBG("");
1021         return -ENOSYS;
1022 }
1023
1024 static uint32_t in_get_channels(const struct audio_stream *stream)
1025 {
1026         DBG("");
1027         return -ENOSYS;
1028 }
1029
1030 static audio_format_t in_get_format(const struct audio_stream *stream)
1031 {
1032         DBG("");
1033         return -ENOSYS;
1034 }
1035
1036 static int in_set_format(struct audio_stream *stream, audio_format_t format)
1037 {
1038         DBG("");
1039         return -ENOSYS;
1040 }
1041
1042 static int in_standby(struct audio_stream *stream)
1043 {
1044         DBG("");
1045         return -ENOSYS;
1046 }
1047
1048 static int in_dump(const struct audio_stream *stream, int fd)
1049 {
1050         DBG("");
1051         return -ENOSYS;
1052 }
1053
1054 static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
1055 {
1056         DBG("");
1057         return -ENOSYS;
1058 }
1059
1060 static char *in_get_parameters(const struct audio_stream *stream,
1061                                                         const char *keys)
1062 {
1063         DBG("");
1064         return strdup("");
1065 }
1066
1067 static int in_set_gain(struct audio_stream_in *stream, float gain)
1068 {
1069         DBG("");
1070         return -ENOSYS;
1071 }
1072
1073 static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
1074                                                                 size_t bytes)
1075 {
1076         DBG("");
1077         return -ENOSYS;
1078 }
1079
1080 static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
1081 {
1082         DBG("");
1083         return -ENOSYS;
1084 }
1085
1086 static int in_add_audio_effect(const struct audio_stream *stream,
1087                                                         effect_handle_t effect)
1088 {
1089         DBG("");
1090         return -ENOSYS;
1091 }
1092
1093 static int in_remove_audio_effect(const struct audio_stream *stream,
1094                                                         effect_handle_t effect)
1095 {
1096         DBG("");
1097         return -ENOSYS;
1098 }
1099
1100 static int audio_open_output_stream(struct audio_hw_device *dev,
1101                                         audio_io_handle_t handle,
1102                                         audio_devices_t devices,
1103                                         audio_output_flags_t flags,
1104                                         struct audio_config *config,
1105                                         struct audio_stream_out **stream_out)
1106
1107 {
1108         struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *) dev;
1109         struct a2dp_stream_out *out;
1110         struct audio_preset *preset;
1111         const struct audio_codec *codec;
1112         uint16_t mtu;
1113         int fd;
1114
1115         out = calloc(1, sizeof(struct a2dp_stream_out));
1116         if (!out)
1117                 return -ENOMEM;
1118
1119         DBG("");
1120
1121         out->stream.common.get_sample_rate = out_get_sample_rate;
1122         out->stream.common.set_sample_rate = out_set_sample_rate;
1123         out->stream.common.get_buffer_size = out_get_buffer_size;
1124         out->stream.common.get_channels = out_get_channels;
1125         out->stream.common.get_format = out_get_format;
1126         out->stream.common.set_format = out_set_format;
1127         out->stream.common.standby = out_standby;
1128         out->stream.common.dump = out_dump;
1129         out->stream.common.set_parameters = out_set_parameters;
1130         out->stream.common.get_parameters = out_get_parameters;
1131         out->stream.common.add_audio_effect = out_add_audio_effect;
1132         out->stream.common.remove_audio_effect = out_remove_audio_effect;
1133         out->stream.get_latency = out_get_latency;
1134         out->stream.set_volume = out_set_volume;
1135         out->stream.write = out_write;
1136         out->stream.get_render_position = out_get_render_position;
1137
1138         /* TODO: for now we always use endpoint 0 */
1139         out->ep = &audio_endpoints[0];
1140
1141         if (ipc_open_stream_cmd(out->ep->id, &mtu, &fd, &preset) !=
1142                         AUDIO_STATUS_SUCCESS)
1143                 goto fail;
1144
1145         if (!preset || fd < 0)
1146                 goto fail;
1147
1148         out->ep->fd = fd;
1149
1150         codec = out->ep->codec;
1151
1152         codec->init(preset, mtu, &out->ep->codec_data);
1153         codec->get_config(out->ep->codec_data, &out->cfg);
1154
1155         DBG("rate=%d channels=%d format=%d", out->cfg.rate,
1156                         out->cfg.channels, out->cfg.format);
1157
1158         free(preset);
1159
1160         *stream_out = &out->stream;
1161         a2dp_dev->out = out;
1162
1163         out->audio_state = AUDIO_A2DP_STATE_STANDBY;
1164
1165         return 0;
1166
1167 fail:
1168         free(out);
1169         *stream_out = NULL;
1170         return -EIO;
1171 }
1172
1173 static void audio_close_output_stream(struct audio_hw_device *dev,
1174                                         struct audio_stream_out *stream)
1175 {
1176         struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *) dev;
1177         struct audio_endpoint *ep = a2dp_dev->out->ep;
1178
1179         DBG("");
1180
1181         ipc_close_stream_cmd(ep->id);
1182
1183         if (ep->fd >= 0) {
1184                 close(ep->fd);
1185                 ep->fd = -1;
1186         }
1187
1188         ep->codec->cleanup(ep->codec_data);
1189         ep->codec_data = NULL;
1190
1191         free(stream);
1192         a2dp_dev->out = NULL;
1193 }
1194
1195 static int audio_set_parameters(struct audio_hw_device *dev,
1196                                                         const char *kvpairs)
1197 {
1198         struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *) dev;
1199         struct a2dp_stream_out *out = a2dp_dev->out;
1200
1201         DBG("");
1202
1203         if (!out)
1204                 return 0;
1205
1206         return out->stream.common.set_parameters((struct audio_stream *) out,
1207                                                         kvpairs);
1208 }
1209
1210 static char *audio_get_parameters(const struct audio_hw_device *dev,
1211                                                         const char *keys)
1212 {
1213         DBG("");
1214         return strdup("");
1215 }
1216
1217 static int audio_init_check(const struct audio_hw_device *dev)
1218 {
1219         DBG("");
1220         return 0;
1221 }
1222
1223 static int audio_set_voice_volume(struct audio_hw_device *dev, float volume)
1224 {
1225         DBG("");
1226         return -ENOSYS;
1227 }
1228
1229 static int audio_set_master_volume(struct audio_hw_device *dev, float volume)
1230 {
1231         DBG("");
1232         return -ENOSYS;
1233 }
1234
1235 static int audio_set_mode(struct audio_hw_device *dev, int mode)
1236 {
1237         DBG("");
1238         return -ENOSYS;
1239 }
1240
1241 static int audio_set_mic_mute(struct audio_hw_device *dev, bool state)
1242 {
1243         DBG("");
1244         return -ENOSYS;
1245 }
1246
1247 static int audio_get_mic_mute(const struct audio_hw_device *dev, bool *state)
1248 {
1249         DBG("");
1250         return -ENOSYS;
1251 }
1252
1253 static size_t audio_get_input_buffer_size(const struct audio_hw_device *dev,
1254                                         const struct audio_config *config)
1255 {
1256         DBG("");
1257         return -ENOSYS;
1258 }
1259
1260 static int audio_open_input_stream(struct audio_hw_device *dev,
1261                                         audio_io_handle_t handle,
1262                                         audio_devices_t devices,
1263                                         struct audio_config *config,
1264                                         struct audio_stream_in **stream_in)
1265 {
1266         struct audio_stream_in *in;
1267
1268         DBG("");
1269
1270         in = calloc(1, sizeof(struct audio_stream_in));
1271         if (!in)
1272                 return -ENOMEM;
1273
1274         in->common.get_sample_rate = in_get_sample_rate;
1275         in->common.set_sample_rate = in_set_sample_rate;
1276         in->common.get_buffer_size = in_get_buffer_size;
1277         in->common.get_channels = in_get_channels;
1278         in->common.get_format = in_get_format;
1279         in->common.set_format = in_set_format;
1280         in->common.standby = in_standby;
1281         in->common.dump = in_dump;
1282         in->common.set_parameters = in_set_parameters;
1283         in->common.get_parameters = in_get_parameters;
1284         in->common.add_audio_effect = in_add_audio_effect;
1285         in->common.remove_audio_effect = in_remove_audio_effect;
1286         in->set_gain = in_set_gain;
1287         in->read = in_read;
1288         in->get_input_frames_lost = in_get_input_frames_lost;
1289
1290         *stream_in = in;
1291
1292         return 0;
1293 }
1294
1295 static void audio_close_input_stream(struct audio_hw_device *dev,
1296                                         struct audio_stream_in *stream_in)
1297 {
1298         DBG("");
1299         free(stream_in);
1300 }
1301
1302 static int audio_dump(const audio_hw_device_t *device, int fd)
1303 {
1304         DBG("");
1305         return -ENOSYS;
1306 }
1307
1308 static int audio_close(hw_device_t *device)
1309 {
1310         struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *)device;
1311
1312         DBG("");
1313
1314         pthread_mutex_lock(&close_mutex);
1315         audio_ipc_cleanup();
1316         close_thread = true;
1317         pthread_mutex_unlock(&close_mutex);
1318
1319         pthread_join(ipc_th, NULL);
1320
1321         close(listen_sk);
1322         listen_sk = -1;
1323
1324         free(a2dp_dev);
1325         return 0;
1326 }
1327
1328 static void *ipc_handler(void *data)
1329 {
1330         bool done = false;
1331         struct pollfd pfd;
1332
1333         DBG("");
1334
1335         while (!done) {
1336                 DBG("Waiting for connection ...");
1337                 audio_sk = accept(listen_sk, NULL, NULL);
1338                 if (audio_sk < 0) {
1339                         int err = errno;
1340                         error("audio: Failed to accept socket: %d (%s)", err,
1341                                                                 strerror(err));
1342                         continue;
1343                 }
1344
1345                 DBG("Audio IPC: Connected");
1346
1347                 if (register_endpoints() != AUDIO_STATUS_SUCCESS) {
1348                         error("audio: Failed to register endpoints");
1349
1350                         unregister_endpoints();
1351
1352                         shutdown(audio_sk, SHUT_RDWR);
1353                         continue;
1354                 }
1355
1356                 memset(&pfd, 0, sizeof(pfd));
1357                 pfd.fd = audio_sk;
1358                 pfd.events = POLLHUP | POLLERR | POLLNVAL;
1359
1360                 /* Check if socket is still alive. Empty while loop.*/
1361                 while (poll(&pfd, 1, -1) < 0 && errno == EINTR);
1362
1363                 if (pfd.revents & (POLLHUP | POLLERR | POLLNVAL)) {
1364                         info("Audio HAL: Socket closed");
1365                         audio_sk = -1;
1366                 }
1367
1368                 /*Check if audio_dev is closed */
1369                 pthread_mutex_lock(&close_mutex);
1370                 done = close_thread;
1371                 close_thread = false;
1372                 pthread_mutex_unlock(&close_mutex);
1373         }
1374
1375         unregister_endpoints();
1376
1377         info("Closing Audio IPC thread");
1378         return NULL;
1379 }
1380
1381 static int audio_ipc_init(void)
1382 {
1383         struct sockaddr_un addr;
1384         int err;
1385         int sk;
1386
1387         DBG("");
1388
1389         sk = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
1390         if (sk < 0) {
1391                 err = errno;
1392                 error("audio: Failed to create socket: %d (%s)", err,
1393                                                                 strerror(err));
1394                 return err;
1395         }
1396
1397         memset(&addr, 0, sizeof(addr));
1398         addr.sun_family = AF_UNIX;
1399
1400         memcpy(addr.sun_path, BLUEZ_AUDIO_SK_PATH,
1401                                         sizeof(BLUEZ_AUDIO_SK_PATH));
1402
1403         if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1404                 err = errno;
1405                 error("audio: Failed to bind socket: %d (%s)", err,
1406                                                                 strerror(err));
1407                 goto failed;
1408         }
1409
1410         if (listen(sk, 1) < 0) {
1411                 err = errno;
1412                 error("audio: Failed to listen on the socket: %d (%s)", err,
1413                                                                 strerror(err));
1414                 goto failed;
1415         }
1416
1417         listen_sk = sk;
1418
1419         err = pthread_create(&ipc_th, NULL, ipc_handler, NULL);
1420         if (err) {
1421                 err = -err;
1422                 ipc_th = 0;
1423                 error("audio: Failed to start Audio IPC thread: %d (%s)",
1424                                                         err, strerror(err));
1425                 goto failed;
1426         }
1427
1428         return 0;
1429
1430 failed:
1431         close(sk);
1432         return err;
1433 }
1434
1435 static int audio_open(const hw_module_t *module, const char *name,
1436                                                         hw_device_t **device)
1437 {
1438         struct a2dp_audio_dev *a2dp_dev;
1439         int err;
1440
1441         DBG("");
1442
1443         if (strcmp(name, AUDIO_HARDWARE_INTERFACE)) {
1444                 error("audio: interface %s not matching [%s]", name,
1445                                                 AUDIO_HARDWARE_INTERFACE);
1446                 return -EINVAL;
1447         }
1448
1449         err = audio_ipc_init();
1450         if (err)
1451                 return -err;
1452
1453         a2dp_dev = calloc(1, sizeof(struct a2dp_audio_dev));
1454         if (!a2dp_dev)
1455                 return -ENOMEM;
1456
1457         a2dp_dev->dev.common.tag = HARDWARE_DEVICE_TAG;
1458         a2dp_dev->dev.common.version = AUDIO_DEVICE_API_VERSION_CURRENT;
1459         a2dp_dev->dev.common.module = (struct hw_module_t *) module;
1460         a2dp_dev->dev.common.close = audio_close;
1461
1462         a2dp_dev->dev.init_check = audio_init_check;
1463         a2dp_dev->dev.set_voice_volume = audio_set_voice_volume;
1464         a2dp_dev->dev.set_master_volume = audio_set_master_volume;
1465         a2dp_dev->dev.set_mode = audio_set_mode;
1466         a2dp_dev->dev.set_mic_mute = audio_set_mic_mute;
1467         a2dp_dev->dev.get_mic_mute = audio_get_mic_mute;
1468         a2dp_dev->dev.set_parameters = audio_set_parameters;
1469         a2dp_dev->dev.get_parameters = audio_get_parameters;
1470         a2dp_dev->dev.get_input_buffer_size = audio_get_input_buffer_size;
1471         a2dp_dev->dev.open_output_stream = audio_open_output_stream;
1472         a2dp_dev->dev.close_output_stream = audio_close_output_stream;
1473         a2dp_dev->dev.open_input_stream = audio_open_input_stream;
1474         a2dp_dev->dev.close_input_stream = audio_close_input_stream;
1475         a2dp_dev->dev.dump = audio_dump;
1476
1477         /* Note that &a2dp_dev->dev.common is the same pointer as a2dp_dev.
1478          * This results from the structure of following structs:a2dp_audio_dev,
1479          * audio_hw_device. We will rely on this later in the code.*/
1480         *device = &a2dp_dev->dev.common;
1481
1482         return 0;
1483 }
1484
1485 static struct hw_module_methods_t hal_module_methods = {
1486         .open = audio_open,
1487 };
1488
1489 struct audio_module HAL_MODULE_INFO_SYM = {
1490         .common = {
1491         .tag = HARDWARE_MODULE_TAG,
1492         .version_major = 1,
1493         .version_minor = 0,
1494         .id = AUDIO_HARDWARE_MODULE_ID,
1495         .name = "A2DP Bluez HW HAL",
1496         .author = "Intel Corporation",
1497         .methods = &hal_module_methods,
1498         },
1499 };