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