android/hal-audio.c

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