android/a2dp.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2013-2014  Intel Corporation. All rights reserved.
   6  *
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Lesser General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2.1 of the License, or (at your option) any later version.
  12  *
  13  *  This library is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  Lesser General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU Lesser General Public
  19  *  License along with this library; if not, write to the Free Software
  20  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <stdint.h>
  29 #include <stdbool.h>
  30 #include <stdlib.h>
  31 #include <errno.h>
  32 #include <unistd.h>
  33 #include <fcntl.h>
  34 #include <glib.h>
  35
  36 #include "btio/btio.h"
  37 #include "lib/bluetooth.h"
  38 #include "lib/sdp.h"
  39 #include "lib/sdp_lib.h"
  40 #include "profiles/audio/a2dp-codecs.h"
  41 #include "src/shared/queue.h"
  42 #include "src/log.h"
  43 #include "hal-msg.h"
  44 #include "ipc-common.h"
  45 #include "ipc.h"
  46 #include "a2dp.h"
  47 #include "utils.h"
  48 #include "bluetooth.h"
  49 #include "avdtp.h"
  50 #include "avrcp.h"
  51 #include "audio-msg.h"
  52
  53 #define SVC_HINT_CAPTURING 0x08
  54 #define IDLE_TIMEOUT 1
  55 #define AUDIO_RETRY_TIMEOUT 2
  56
  57 static GIOChannel *server = NULL;
  58 static GSList *devices = NULL;
  59 static GSList *endpoints = NULL;
  60 static GSList *setups = NULL;
  61 static bdaddr_t adapter_addr;
  62 static uint32_t record_id = 0;
  63 static guint audio_retry_id = 0;
  64 static bool audio_retrying = false;
  65
  66 static struct ipc *hal_ipc = NULL;
  67 static struct ipc *audio_ipc = NULL;
  68
  69 static struct queue *lseps = NULL;
  70
  71 struct a2dp_preset {
  72         void *data;
  73         int8_t len;
  74 };
  75
  76 struct a2dp_endpoint {
  77         uint8_t id;
  78         uint8_t codec;
  79         struct avdtp_local_sep *sep;
  80         struct a2dp_preset *caps;
  81         GSList *presets;
  82 };
  83
  84 struct a2dp_device {
  85         bdaddr_t        dst;
  86         uint8_t         state;
  87         GIOChannel      *io;
  88         struct avdtp    *session;
  89         guint           idle_id;
  90 };
  91
  92 struct a2dp_setup {
  93         struct a2dp_device *dev;
  94         struct a2dp_endpoint *endpoint;
  95         struct a2dp_preset *preset;
  96         struct avdtp_stream *stream;
  97         uint8_t state;
  98 };
  99
 100 static int device_cmp(gconstpointer s, gconstpointer user_data)
 101 {
 102         const struct a2dp_device *dev = s;
 103         const bdaddr_t *dst = user_data;
 104
 105         return bacmp(&dev->dst, dst);
 106 }
 107
 108 static void preset_free(void *data)
 109 {
 110         struct a2dp_preset *preset = data;
 111
 112         g_free(preset->data);
 113         g_free(preset);
 114 }
 115
 116 static void unregister_endpoint(void *data)
 117 {
 118         struct a2dp_endpoint *endpoint = data;
 119
 120         if (endpoint->sep)
 121                 avdtp_unregister_sep(lseps, endpoint->sep);
 122
 123         if (endpoint->caps)
 124                 preset_free(endpoint->caps);
 125
 126         g_slist_free_full(endpoint->presets, preset_free);
 127
 128         g_free(endpoint);
 129 }
 130
 131 static void setup_free(void *data)
 132 {
 133         struct a2dp_setup *setup = data;
 134
 135         if (!g_slist_find(setup->endpoint->presets, setup->preset))
 136                 preset_free(setup->preset);
 137
 138         g_free(setup);
 139 }
 140
 141 static void setup_remove(struct a2dp_setup *setup)
 142 {
 143         setups = g_slist_remove(setups, setup);
 144         setup_free(setup);
 145 }
 146
 147 static void setup_remove_all_by_dev(struct a2dp_device *dev)
 148 {
 149         GSList *l = setups;
 150
 151         while (l) {
 152                 struct a2dp_setup *setup = l->data;
 153                 GSList *next = g_slist_next(l);
 154
 155                 if (setup->dev == dev)
 156                         setup_remove(setup);
 157
 158                 l = next;
 159         }
 160 }
 161
 162 static void a2dp_device_free(void *data)
 163 {
 164         struct a2dp_device *dev = data;
 165
 166         if (dev->idle_id > 0)
 167                 g_source_remove(dev->idle_id);
 168
 169         if (dev->session)
 170                 avdtp_unref(dev->session);
 171
 172         if (dev->io) {
 173                 g_io_channel_shutdown(dev->io, FALSE, NULL);
 174                 g_io_channel_unref(dev->io);
 175         }
 176
 177         setup_remove_all_by_dev(dev);
 178
 179         g_free(dev);
 180 }
 181
 182 static void a2dp_device_remove(struct a2dp_device *dev)
 183 {
 184         devices = g_slist_remove(devices, dev);
 185         a2dp_device_free(dev);
 186 }
 187
 188 static struct a2dp_device *a2dp_device_new(const bdaddr_t *dst)
 189 {
 190         struct a2dp_device *dev;
 191
 192         dev = g_new0(struct a2dp_device, 1);
 193         bacpy(&dev->dst, dst);
 194         devices = g_slist_prepend(devices, dev);
 195
 196         return dev;
 197 }
 198
 199 static bool a2dp_device_connect(struct a2dp_device *dev, BtIOConnect cb)
 200 {
 201         GError *err = NULL;
 202
 203         dev->io = bt_io_connect(cb, dev, NULL, &err,
 204                                         BT_IO_OPT_SOURCE_BDADDR, &adapter_addr,
 205                                         BT_IO_OPT_DEST_BDADDR, &dev->dst,
 206                                         BT_IO_OPT_PSM, AVDTP_PSM,
 207                                         BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_MEDIUM,
 208                                         BT_IO_OPT_INVALID);
 209         if (err) {
 210                 error("%s", err->message);
 211                 g_error_free(err);
 212                 return false;
 213         }
 214
 215         return true;
 216 }
 217
 218 static void bt_a2dp_notify_state(struct a2dp_device *dev, uint8_t state)
 219 {
 220         struct hal_ev_a2dp_conn_state ev;
 221         char address[18];
 222
 223         if (dev->state == state)
 224                 return;
 225
 226         dev->state = state;
 227
 228         ba2str(&dev->dst, address);
 229         DBG("device %s state %u", address, state);
 230
 231         bdaddr2android(&dev->dst, ev.bdaddr);
 232         ev.state = state;
 233
 234         ipc_send_notif(hal_ipc, HAL_SERVICE_ID_A2DP, HAL_EV_A2DP_CONN_STATE,
 235                                                         sizeof(ev), &ev);
 236
 237         if (state != HAL_A2DP_STATE_DISCONNECTED)
 238                 return;
 239
 240         bt_avrcp_disconnect(&dev->dst);
 241
 242         a2dp_device_remove(dev);
 243 }
 244
 245 static void bt_audio_notify_state(struct a2dp_setup *setup, uint8_t state)
 246 {
 247         struct hal_ev_a2dp_audio_state ev;
 248         char address[18];
 249
 250         if (setup->state == state)
 251                 return;
 252
 253         setup->state = state;
 254
 255         ba2str(&setup->dev->dst, address);
 256         DBG("device %s state %u", address, state);
 257
 258         bdaddr2android(&setup->dev->dst, ev.bdaddr);
 259         ev.state = state;
 260
 261         ipc_send_notif(hal_ipc, HAL_SERVICE_ID_A2DP, HAL_EV_A2DP_AUDIO_STATE,
 262                                                         sizeof(ev), &ev);
 263 }
 264
 265 static void disconnect_cb(void *user_data)
 266 {
 267         struct a2dp_device *dev = user_data;
 268
 269         bt_a2dp_notify_state(dev, HAL_A2DP_STATE_DISCONNECTED);
 270 }
 271
 272 static int sbc_check_config(void *caps, uint8_t caps_len, void *conf,
 273                                                         uint8_t conf_len)
 274 {
 275         a2dp_sbc_t *cap, *config;
 276
 277         if (conf_len != caps_len || conf_len != sizeof(a2dp_sbc_t)) {
 278                 error("SBC: Invalid configuration size (%u)", conf_len);
 279                 return -EINVAL;
 280         }
 281
 282         cap = caps;
 283         config = conf;
 284
 285         if (!(cap->frequency & config->frequency)) {
 286                 error("SBC: Unsupported frequency (%u) by endpoint",
 287                                                         config->frequency);
 288                 return -EINVAL;
 289         }
 290
 291         if (!(cap->channel_mode & config->channel_mode)) {
 292                 error("SBC: Unsupported channel mode (%u) by endpoint",
 293                                                         config->channel_mode);
 294                 return -EINVAL;
 295         }
 296
 297         if (!(cap->block_length & config->block_length)) {
 298                 error("SBC: Unsupported block length (%u) by endpoint",
 299                                                         config->block_length);
 300                 return -EINVAL;
 301         }
 302
 303         if (!(cap->allocation_method & config->allocation_method)) {
 304                 error("SBC: Unsupported allocation method (%u) by endpoint",
 305                                                         config->block_length);
 306                 return -EINVAL;
 307         }
 308
 309         if (config->max_bitpool < cap->min_bitpool) {
 310                 error("SBC: Invalid maximun bitpool (%u < %u)",
 311                                         config->max_bitpool, cap->min_bitpool);
 312                 return -EINVAL;
 313         }
 314
 315         if (config->min_bitpool > cap->max_bitpool) {
 316                 error("SBC: Invalid minimun bitpool (%u > %u)",
 317                                         config->min_bitpool, cap->min_bitpool);
 318                 return -EINVAL;
 319         }
 320
 321         if (config->max_bitpool > cap->max_bitpool)
 322                 return -ERANGE;
 323
 324         if (config->min_bitpool < cap->min_bitpool)
 325                 return -ERANGE;
 326
 327         return 0;
 328 }
 329
 330 static int aac_check_config(void *caps, uint8_t caps_len, void *conf,
 331                                                         uint8_t conf_len)
 332 {
 333         a2dp_aac_t *cap, *config;
 334
 335         if (conf_len != caps_len || conf_len != sizeof(a2dp_aac_t)) {
 336                 error("AAC: Invalid configuration size (%u)", conf_len);
 337                 return -EINVAL;
 338         }
 339
 340         cap = caps;
 341         config = conf;
 342
 343         if (!(cap->object_type & config->object_type)) {
 344                 error("AAC: Unsupported object type (%u) by endpoint",
 345                                                         config->object_type);
 346                 return -EINVAL;
 347         }
 348
 349         if (!(AAC_GET_FREQUENCY(*cap) & AAC_GET_FREQUENCY(*config))) {
 350                 error("AAC: Unsupported frequency (%u) by endpoint",
 351                                                 AAC_GET_FREQUENCY(*config));
 352                 return -EINVAL;
 353         }
 354
 355         if (!(cap->channels & config->channels)) {
 356                 error("AAC: Unsupported channels (%u) by endpoint",
 357                                                         config->channels);
 358                 return -EINVAL;
 359         }
 360
 361         /* VBR support in SNK is mandatory but let's make sure we don't try to
 362          * have VBR on remote which for some reason does not support it
 363          */
 364         if (!cap->vbr && config->vbr) {
 365                 error("AAC: Unsupported VBR (%u) by endpoint",
 366                                                         config->vbr);
 367                 return -EINVAL;
 368         }
 369
 370         if (AAC_GET_BITRATE(*cap) < AAC_GET_BITRATE(*config))
 371                 return -ERANGE;
 372
 373         return 0;
 374 }
 375
 376 static int aptx_check_config(void *caps, uint8_t caps_len, void *conf,
 377                                                         uint8_t conf_len)
 378 {
 379         a2dp_aptx_t *cap, *config;
 380
 381         if (conf_len != caps_len || conf_len != sizeof(a2dp_aptx_t)) {
 382                 error("APTX: Invalid configuration size (%u)", conf_len);
 383                 return -EINVAL;
 384         }
 385
 386         cap = caps;
 387         config = conf;
 388
 389         if (!(cap->frequency & config->frequency)) {
 390                 error("APTX: Unsupported frequenct (%u) by endpoint",
 391                                                         config->frequency);
 392                 return -EINVAL;
 393         }
 394
 395         if (!(cap->channel_mode & config->channel_mode)) {
 396                 error("APTX: Unsupported channel mode (%u) by endpoint",
 397                                                         config->channel_mode);
 398                 return -EINVAL;
 399         }
 400
 401         return 0;
 402 }
 403
 404 static int check_capabilities(struct a2dp_preset *preset,
 405                                 struct avdtp_media_codec_capability *codec,
 406                                 uint8_t codec_len)
 407 {
 408         a2dp_vendor_codec_t *vndcodec;
 409
 410         /* Codec specific */
 411         switch (codec->media_codec_type) {
 412         case A2DP_CODEC_SBC:
 413                 return sbc_check_config(codec->data, codec_len, preset->data,
 414                                                                 preset->len);
 415         case A2DP_CODEC_MPEG24:
 416                 return aac_check_config(codec->data, codec_len, preset->data,
 417                                                                 preset->len);
 418         case A2DP_CODEC_VENDOR:
 419                 vndcodec = (void *) codec->data;
 420                 if (btohl(vndcodec->vendor_id) == APTX_VENDOR_ID &&
 421                                 btohs(vndcodec->codec_id) == APTX_CODEC_ID)
 422                         return aptx_check_config(codec->data, codec_len,
 423                                                 preset->data, preset->len);
 424                 return -EINVAL;
 425         default:
 426                 return -EINVAL;
 427         }
 428 }
 429
 430 static struct a2dp_preset *sbc_select_range(void *caps, uint8_t caps_len,
 431                                                 void *conf, uint8_t conf_len)
 432 {
 433         struct a2dp_preset *p;
 434         a2dp_sbc_t *cap, *config;
 435
 436         cap = caps;
 437         config = conf;
 438
 439         config->min_bitpool = MAX(config->min_bitpool, cap->min_bitpool);
 440         config->max_bitpool = MIN(config->max_bitpool, cap->max_bitpool);
 441
 442         p = g_new0(struct a2dp_preset, 1);
 443         p->len = conf_len;
 444         p->data = g_memdup(conf, p->len);
 445
 446         return p;
 447 }
 448
 449 static struct a2dp_preset *aac_select_range(void *caps, uint8_t caps_len,
 450                                                 void *conf, uint8_t conf_len)
 451 {
 452         struct a2dp_preset *p;
 453         a2dp_aac_t *cap, *config;
 454         uint32_t bitrate;
 455
 456         cap = caps;
 457         config = conf;
 458
 459         bitrate = MIN(AAC_GET_BITRATE(*cap), AAC_GET_BITRATE(*config));
 460         AAC_SET_BITRATE(*config, bitrate);
 461
 462         p = g_new0(struct a2dp_preset, 1);
 463         p->len = conf_len;
 464         p->data = g_memdup(conf, p->len);
 465
 466         return p;
 467 }
 468
 469 static struct a2dp_preset *select_preset_range(struct a2dp_preset *preset,
 470                                 struct avdtp_media_codec_capability *codec,
 471                                 uint8_t codec_len)
 472 {
 473         /* Codec specific */
 474         switch (codec->media_codec_type) {
 475         case A2DP_CODEC_SBC:
 476                 return sbc_select_range(codec->data, codec_len, preset->data,
 477                                                                 preset->len);
 478         case A2DP_CODEC_MPEG24:
 479                 return aac_select_range(codec->data, codec_len, preset->data,
 480                                                                 preset->len);
 481         default:
 482                 return NULL;
 483         }
 484 }
 485
 486 static struct a2dp_preset *select_preset(struct a2dp_endpoint *endpoint,
 487                                                 struct avdtp_remote_sep *rsep)
 488 {
 489         struct avdtp_service_capability *service;
 490         struct avdtp_media_codec_capability *codec;
 491         GSList *l;
 492         uint8_t codec_len;
 493
 494         service = avdtp_get_codec(rsep);
 495         codec = (struct avdtp_media_codec_capability *) service->data;
 496         codec_len = service->length - sizeof(*codec);
 497
 498         for (l = endpoint->presets; l; l = g_slist_next(l)) {
 499                 struct a2dp_preset *preset = l->data;
 500                 int err;
 501
 502                 err = check_capabilities(preset, codec, codec_len);
 503                 if (err == 0)
 504                         return preset;
 505
 506                 if (err == -ERANGE)
 507                         return select_preset_range(preset, codec, codec_len);
 508         }
 509
 510         return NULL;
 511 }
 512
 513 static void setup_add(struct a2dp_device *dev, struct a2dp_endpoint *endpoint,
 514                         struct a2dp_preset *preset, struct avdtp_stream *stream)
 515 {
 516         struct a2dp_setup *setup;
 517
 518         setup = g_new0(struct a2dp_setup, 1);
 519         setup->dev = dev;
 520         setup->endpoint = endpoint;
 521         setup->preset = preset;
 522         setup->stream = stream;
 523         setups = g_slist_append(setups, setup);
 524
 525         if (dev->idle_id > 0) {
 526                 g_source_remove(dev->idle_id);
 527                 dev->idle_id = 0;
 528         }
 529 }
 530
 531 static int select_configuration(struct a2dp_device *dev,
 532                                 struct a2dp_endpoint *endpoint,
 533                                 struct avdtp_remote_sep *rsep)
 534 {
 535         struct a2dp_preset *preset;
 536         struct avdtp_stream *stream;
 537         struct avdtp_service_capability *service;
 538         struct avdtp_media_codec_capability *codec;
 539         GSList *caps;
 540         int err;
 541
 542         preset = select_preset(endpoint, rsep);
 543         if (!preset) {
 544                 error("Unable to select codec preset");
 545                 return -EINVAL;
 546         }
 547
 548         service = avdtp_service_cap_new(AVDTP_MEDIA_TRANSPORT, NULL, 0);
 549         caps = g_slist_append(NULL, service);
 550
 551         codec = g_malloc0(sizeof(*codec) + preset->len);
 552         codec->media_type = AVDTP_MEDIA_TYPE_AUDIO;
 553         codec->media_codec_type = endpoint->codec;
 554         memcpy(codec->data, preset->data, preset->len);
 555
 556         service = avdtp_service_cap_new(AVDTP_MEDIA_CODEC, codec,
 557                                                 sizeof(*codec) + preset->len);
 558         caps = g_slist_append(caps, service);
 559
 560         g_free(codec);
 561
 562         err = avdtp_set_configuration(dev->session, rsep, endpoint->sep, caps,
 563                                                                 &stream);
 564         g_slist_free_full(caps, g_free);
 565         if (err < 0) {
 566                 error("avdtp_set_configuration: %s", strerror(-err));
 567                 return err;
 568         }
 569
 570         setup_add(dev, endpoint, preset, stream);
 571
 572         return 0;
 573 }
 574
 575 static void discover_cb(struct avdtp *session, GSList *seps,
 576                                 struct avdtp_error *err, void *user_data)
 577 {
 578         struct a2dp_device *dev = user_data;
 579         struct a2dp_endpoint *endpoint = NULL;
 580         struct avdtp_remote_sep *rsep = NULL;
 581         GSList *l;
 582
 583         for (l = endpoints; l; l = g_slist_next(l)) {
 584                 endpoint = l->data;
 585
 586                 rsep = avdtp_find_remote_sep(session, endpoint->sep);
 587                 if (rsep)
 588                         break;
 589         }
 590
 591         if (!rsep) {
 592                 error("Unable to find matching endpoint");
 593                 goto failed;
 594         }
 595
 596         if (select_configuration(dev, endpoint, rsep) < 0)
 597                 goto failed;
 598
 599         return;
 600
 601 failed:
 602         avdtp_shutdown(session);
 603 }
 604
 605 static gboolean idle_timeout(gpointer user_data)
 606 {
 607         struct a2dp_device *dev = user_data;
 608         int err;
 609
 610         dev->idle_id = 0;
 611
 612         err = avdtp_discover(dev->session, discover_cb, dev);
 613         if (err == 0)
 614                 return FALSE;
 615
 616         error("avdtp_discover: %s", strerror(-err));
 617         bt_a2dp_notify_state(dev, HAL_A2DP_STATE_DISCONNECTED);
 618
 619         return FALSE;
 620 }
 621
 622 static void signaling_connect_cb(GIOChannel *chan, GError *err,
 623                                                         gpointer user_data)
 624 {
 625         struct a2dp_device *dev = user_data;
 626         struct avdtp *session;
 627         uint16_t imtu, omtu;
 628         GError *gerr = NULL;
 629         int fd;
 630
 631         if (err) {
 632                 bt_a2dp_notify_state(dev, HAL_A2DP_STATE_DISCONNECTED);
 633                 error("%s", err->message);
 634                 return;
 635         }
 636
 637         bt_io_get(chan, &gerr,
 638                         BT_IO_OPT_IMTU, &imtu,
 639                         BT_IO_OPT_OMTU, &omtu,
 640                         BT_IO_OPT_INVALID);
 641         if (gerr) {
 642                 error("%s", gerr->message);
 643                 g_error_free(gerr);
 644                 goto failed;
 645         }
 646
 647         fd = g_io_channel_unix_get_fd(chan);
 648
 649         /* FIXME: Add proper version */
 650         session = avdtp_new(fd, imtu, omtu, 0x0100, lseps);
 651         if (!session)
 652                 goto failed;
 653
 654         dev->session = session;
 655
 656         avdtp_add_disconnect_cb(dev->session, disconnect_cb, dev);
 657
 658         /* Proceed to stream setup if initiator */
 659         if (dev->io) {
 660                 int perr;
 661
 662                 g_io_channel_unref(dev->io);
 663                 dev->io = NULL;
 664
 665                 perr = avdtp_discover(dev->session, discover_cb, dev);
 666                 if (perr < 0) {
 667                         error("avdtp_discover: %s", strerror(-perr));
 668                         goto failed;
 669                 }
 670                 bt_avrcp_connect(&dev->dst);
 671         } else /* Init idle timeout to discover */
 672                 dev->idle_id = g_timeout_add_seconds(IDLE_TIMEOUT, idle_timeout,
 673                                                                         dev);
 674
 675         return;
 676
 677 failed:
 678         bt_a2dp_notify_state(dev, HAL_A2DP_STATE_DISCONNECTED);
 679 }
 680
 681 static void bt_a2dp_connect(const void *buf, uint16_t len)
 682 {
 683         const struct hal_cmd_a2dp_connect *cmd = buf;
 684         struct a2dp_device *dev;
 685         uint8_t status;
 686         char addr[18];
 687         bdaddr_t dst;
 688         GSList *l;
 689
 690         DBG("");
 691
 692         android2bdaddr(&cmd->bdaddr, &dst);
 693
 694         l = g_slist_find_custom(devices, &dst, device_cmp);
 695         if (l) {
 696                 status = HAL_STATUS_FAILED;
 697                 goto failed;
 698         }
 699
 700         dev = a2dp_device_new(&dst);
 701         if (!a2dp_device_connect(dev, signaling_connect_cb)) {
 702                 a2dp_device_remove(dev);
 703                 status = HAL_STATUS_FAILED;
 704                 goto failed;
 705         }
 706
 707         ba2str(&dev->dst, addr);
 708         DBG("connecting to %s", addr);
 709
 710         bt_a2dp_notify_state(dev, HAL_A2DP_STATE_CONNECTING);
 711
 712         status = HAL_STATUS_SUCCESS;
 713
 714 failed:
 715         ipc_send_rsp(hal_ipc, HAL_SERVICE_ID_A2DP, HAL_OP_A2DP_CONNECT, status);
 716 }
 717
 718 static void bt_a2dp_disconnect(const void *buf, uint16_t len)
 719 {
 720         const struct hal_cmd_a2dp_connect *cmd = buf;
 721         uint8_t status;
 722         struct a2dp_device *dev;
 723         GSList *l;
 724         bdaddr_t dst;
 725
 726         DBG("");
 727
 728         android2bdaddr(&cmd->bdaddr, &dst);
 729
 730         l = g_slist_find_custom(devices, &dst, device_cmp);
 731         if (!l) {
 732                 status = HAL_STATUS_FAILED;
 733                 goto failed;
 734         }
 735
 736         dev = l->data;
 737         status = HAL_STATUS_SUCCESS;
 738
 739         if (dev->io) {
 740                 bt_a2dp_notify_state(dev, HAL_A2DP_STATE_DISCONNECTED);
 741                 goto failed;
 742         }
 743
 744         /* Wait AVDTP session to shutdown */
 745         avdtp_shutdown(dev->session);
 746         bt_a2dp_notify_state(dev, HAL_A2DP_STATE_DISCONNECTING);
 747
 748 failed:
 749         ipc_send_rsp(hal_ipc, HAL_SERVICE_ID_A2DP, HAL_OP_A2DP_DISCONNECT,
 750                                                                         status);
 751 }
 752
 753 static const struct ipc_handler cmd_handlers[] = {
 754         /* HAL_OP_A2DP_CONNECT */
 755         { bt_a2dp_connect, false, sizeof(struct hal_cmd_a2dp_connect) },
 756         /* HAL_OP_A2DP_DISCONNECT */
 757         { bt_a2dp_disconnect, false, sizeof(struct hal_cmd_a2dp_disconnect) },
 758 };
 759
 760 static struct a2dp_setup *find_setup_by_device(struct a2dp_device *dev)
 761 {
 762         GSList *l;
 763
 764         for (l = setups; l; l = g_slist_next(l)) {
 765                 struct a2dp_setup *setup = l->data;
 766
 767                 if (setup->dev == dev)
 768                         return setup;
 769         }
 770
 771         return NULL;
 772 }
 773
 774 static void transport_connect_cb(GIOChannel *chan, GError *err,
 775                                                         gpointer user_data)
 776 {
 777         struct a2dp_device *dev = user_data;
 778         struct a2dp_setup *setup;
 779         uint16_t imtu, omtu;
 780         GError *gerr = NULL;
 781         int fd;
 782
 783         if (err) {
 784                 error("%s", err->message);
 785                 return;
 786         }
 787
 788         setup = find_setup_by_device(dev);
 789         if (!setup) {
 790                 error("Unable to find stream setup");
 791                 return;
 792         }
 793
 794         bt_io_get(chan, &gerr,
 795                         BT_IO_OPT_IMTU, &imtu,
 796                         BT_IO_OPT_OMTU, &omtu,
 797                         BT_IO_OPT_INVALID);
 798         if (gerr) {
 799                 error("%s", gerr->message);
 800                 g_error_free(gerr);
 801                 return;
 802         }
 803
 804         fd = g_io_channel_unix_get_fd(chan);
 805
 806         if (!avdtp_stream_set_transport(setup->stream, fd, imtu, omtu)) {
 807                 error("avdtp_stream_set_transport: failed");
 808                 return;
 809         }
 810
 811         g_io_channel_set_close_on_unref(chan, FALSE);
 812
 813         if (dev->io) {
 814                 g_io_channel_unref(dev->io);
 815                 dev->io = NULL;
 816         }
 817
 818         bt_a2dp_notify_state(dev, HAL_A2DP_STATE_CONNECTED);
 819 }
 820
 821 static void connect_cb(GIOChannel *chan, GError *err, gpointer user_data)
 822 {
 823         struct a2dp_device *dev;
 824         bdaddr_t dst;
 825         char address[18];
 826         GError *gerr = NULL;
 827         GSList *l;
 828
 829         if (err) {
 830                 error("%s", err->message);
 831                 return;
 832         }
 833
 834         bt_io_get(chan, &gerr,
 835                         BT_IO_OPT_DEST_BDADDR, &dst,
 836                         BT_IO_OPT_INVALID);
 837         if (gerr) {
 838                 error("%s", gerr->message);
 839                 g_error_free(gerr);
 840                 g_io_channel_shutdown(chan, TRUE, NULL);
 841                 return;
 842         }
 843
 844         ba2str(&dst, address);
 845         DBG("Incoming connection from %s", address);
 846
 847         l = g_slist_find_custom(devices, &dst, device_cmp);
 848         if (l) {
 849                 transport_connect_cb(chan, err, l->data);
 850                 return;
 851         }
 852
 853         dev = a2dp_device_new(&dst);
 854         bt_a2dp_notify_state(dev, HAL_A2DP_STATE_CONNECTING);
 855         signaling_connect_cb(chan, err, dev);
 856 }
 857
 858 static sdp_record_t *a2dp_record(void)
 859 {
 860         sdp_list_t *svclass_id, *pfseq, *apseq, *root;
 861         uuid_t root_uuid, l2cap_uuid, avdtp_uuid, a2dp_uuid;
 862         sdp_profile_desc_t profile[1];
 863         sdp_list_t *aproto, *proto[2];
 864         sdp_record_t *record;
 865         sdp_data_t *psm, *version, *features;
 866         uint16_t lp = AVDTP_UUID;
 867         uint16_t a2dp_ver = 0x0103, avdtp_ver = 0x0103, feat = 0x000f;
 868
 869         record = sdp_record_alloc();
 870         if (!record)
 871                 return NULL;
 872
 873         sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP);
 874         root = sdp_list_append(NULL, &root_uuid);
 875         sdp_set_browse_groups(record, root);
 876
 877         sdp_uuid16_create(&a2dp_uuid, AUDIO_SOURCE_SVCLASS_ID);
 878         svclass_id = sdp_list_append(NULL, &a2dp_uuid);
 879         sdp_set_service_classes(record, svclass_id);
 880
 881         sdp_uuid16_create(&profile[0].uuid, ADVANCED_AUDIO_PROFILE_ID);
 882         profile[0].version = a2dp_ver;
 883         pfseq = sdp_list_append(NULL, &profile[0]);
 884         sdp_set_profile_descs(record, pfseq);
 885
 886         sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
 887         proto[0] = sdp_list_append(NULL, &l2cap_uuid);
 888         psm = sdp_data_alloc(SDP_UINT16, &lp);
 889         proto[0] = sdp_list_append(proto[0], psm);
 890         apseq = sdp_list_append(NULL, proto[0]);
 891
 892         sdp_uuid16_create(&avdtp_uuid, AVDTP_UUID);
 893         proto[1] = sdp_list_append(NULL, &avdtp_uuid);
 894         version = sdp_data_alloc(SDP_UINT16, &avdtp_ver);
 895         proto[1] = sdp_list_append(proto[1], version);
 896         apseq = sdp_list_append(apseq, proto[1]);
 897
 898         aproto = sdp_list_append(NULL, apseq);
 899         sdp_set_access_protos(record, aproto);
 900
 901         features = sdp_data_alloc(SDP_UINT16, &feat);
 902         sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features);
 903
 904         sdp_set_info_attr(record, "Audio Source", NULL, NULL);
 905
 906         sdp_data_free(psm);
 907         sdp_data_free(version);
 908         sdp_list_free(proto[0], NULL);
 909         sdp_list_free(proto[1], NULL);
 910         sdp_list_free(apseq, NULL);
 911         sdp_list_free(pfseq, NULL);
 912         sdp_list_free(aproto, NULL);
 913         sdp_list_free(root, NULL);
 914         sdp_list_free(svclass_id, NULL);
 915
 916         return record;
 917 }
 918
 919 static gboolean sep_getcap_ind(struct avdtp *session,
 920                                         struct avdtp_local_sep *sep,
 921                                         GSList **caps, uint8_t *err,
 922                                         void *user_data)
 923 {
 924         struct a2dp_endpoint *endpoint = user_data;
 925         struct a2dp_preset *cap = endpoint->caps;
 926         struct avdtp_service_capability *service;
 927         struct avdtp_media_codec_capability *codec;
 928
 929         *caps = NULL;
 930
 931         service = avdtp_service_cap_new(AVDTP_MEDIA_TRANSPORT, NULL, 0);
 932         *caps = g_slist_append(*caps, service);
 933
 934         codec = g_malloc0(sizeof(*codec) + cap->len);
 935         codec->media_type = AVDTP_MEDIA_TYPE_AUDIO;
 936         codec->media_codec_type = endpoint->codec;
 937         memcpy(codec->data, cap->data, cap->len);
 938
 939         service = avdtp_service_cap_new(AVDTP_MEDIA_CODEC, codec,
 940                                                 sizeof(*codec) + cap->len);
 941         *caps = g_slist_append(*caps, service);
 942         g_free(codec);
 943
 944         return TRUE;
 945 }
 946
 947 static int check_config(struct a2dp_endpoint *endpoint,
 948                                                 struct a2dp_preset *config)
 949 {
 950         GSList *l;
 951         struct a2dp_preset *caps;
 952
 953         for (l = endpoint->presets; l; l = g_slist_next(l)) {
 954                 struct a2dp_preset *preset = l->data;
 955
 956                 if (preset->len != config->len)
 957                         continue;
 958
 959                 if (memcmp(preset->data, config->data, preset->len) == 0)
 960                         return 0;
 961         }
 962
 963         caps = endpoint->caps;
 964
 965         /* Codec specific */
 966         switch (endpoint->codec) {
 967         case A2DP_CODEC_SBC:
 968                 return sbc_check_config(caps->data, caps->len, config->data,
 969                                                                 config->len);
 970         default:
 971                 return -EINVAL;
 972         }
 973 }
 974
 975 static struct a2dp_device *find_device_by_session(struct avdtp *session)
 976 {
 977         GSList *l;
 978
 979         for (l = devices; l; l = g_slist_next(l)) {
 980                 struct a2dp_device *dev = l->data;
 981
 982                 if (dev->session == session)
 983                         return dev;
 984         }
 985
 986         return NULL;
 987 }
 988
 989 static struct a2dp_setup *find_setup(uint8_t id)
 990 {
 991         GSList *l;
 992
 993         for (l = setups; l; l = g_slist_next(l)) {
 994                 struct a2dp_setup *setup = l->data;
 995
 996                 if (setup->endpoint->id == id)
 997                         return setup;
 998         }
 999
1000         return NULL;
1001 }
1002
1003 static void setup_remove_by_id(uint8_t id)
1004 {
1005         struct a2dp_setup *setup;
1006
1007         setup = find_setup(id);
1008         if (!setup) {
1009                 error("Unable to find stream setup for endpoint %u", id);
1010                 return;
1011         }
1012
1013         setup_remove(setup);
1014 }
1015
1016 static gboolean sep_setconf_ind(struct avdtp *session,
1017                                                 struct avdtp_local_sep *sep,
1018                                                 struct avdtp_stream *stream,
1019                                                 GSList *caps,
1020                                                 avdtp_set_configuration_cb cb,
1021                                                 void *user_data)
1022 {
1023         struct a2dp_endpoint *endpoint = user_data;
1024         struct a2dp_device *dev;
1025         struct a2dp_preset *preset = NULL;
1026
1027         DBG("");
1028
1029         dev = find_device_by_session(session);
1030         if (!dev) {
1031                 error("Unable to find device for session %p", session);
1032                 return FALSE;
1033         }
1034
1035         for (; caps != NULL; caps = g_slist_next(caps)) {
1036                 struct avdtp_service_capability *cap = caps->data;
1037                 struct avdtp_media_codec_capability *codec;
1038
1039                 if (cap->category == AVDTP_DELAY_REPORTING)
1040                         return FALSE;
1041
1042                 if (cap->category != AVDTP_MEDIA_CODEC)
1043                         continue;
1044
1045                 codec = (struct avdtp_media_codec_capability *) cap->data;
1046
1047                 if (codec->media_codec_type != endpoint->codec)
1048                         return FALSE;
1049
1050                 preset = g_new0(struct a2dp_preset, 1);
1051                 preset->len = cap->length - sizeof(*codec);
1052                 preset->data = g_memdup(codec->data, preset->len);
1053
1054                 if (check_config(endpoint, preset) < 0) {
1055                         preset_free(preset);
1056                         return FALSE;
1057                 }
1058         }
1059
1060         if (!preset)
1061                 return FALSE;
1062
1063         setup_add(dev, endpoint, preset, stream);
1064
1065         cb(session, stream, NULL);
1066
1067         return TRUE;
1068 }
1069
1070 static gboolean sep_open_ind(struct avdtp *session, struct avdtp_local_sep *sep,
1071                                 struct avdtp_stream *stream, uint8_t *err,
1072                                 void *user_data)
1073 {
1074         struct a2dp_endpoint *endpoint = user_data;
1075         struct a2dp_setup *setup;
1076
1077         DBG("");
1078
1079         setup = find_setup(endpoint->id);
1080         if (!setup) {
1081                 error("Unable to find stream setup for endpoint %u",
1082                                                                 endpoint->id);
1083                 *err = AVDTP_SEP_NOT_IN_USE;
1084                 return FALSE;
1085         }
1086
1087         return TRUE;
1088 }
1089
1090 static gboolean sep_close_ind(struct avdtp *session,
1091                                                 struct avdtp_local_sep *sep,
1092                                                 struct avdtp_stream *stream,
1093                                                 uint8_t *err,
1094                                                 void *user_data)
1095 {
1096         struct a2dp_endpoint *endpoint = user_data;
1097         struct a2dp_setup *setup;
1098
1099         DBG("");
1100
1101         setup = find_setup(endpoint->id);
1102         if (!setup) {
1103                 error("Unable to find stream setup for endpoint %u",
1104                                                                 endpoint->id);
1105                 *err = AVDTP_SEP_NOT_IN_USE;
1106                 return FALSE;
1107         }
1108
1109         bt_audio_notify_state(setup, HAL_AUDIO_STOPPED);
1110
1111         setup_remove(setup);
1112
1113         return TRUE;
1114 }
1115
1116 static gboolean sep_start_ind(struct avdtp *session,
1117                                                 struct avdtp_local_sep *sep,
1118                                                 struct avdtp_stream *stream,
1119                                                 uint8_t *err,
1120                                                 void *user_data)
1121 {
1122         struct a2dp_endpoint *endpoint = user_data;
1123         struct a2dp_setup *setup;
1124
1125         DBG("");
1126
1127         setup = find_setup(endpoint->id);
1128         if (!setup) {
1129                 error("Unable to find stream setup for endpoint %u",
1130                                                                 endpoint->id);
1131                 *err = AVDTP_SEP_NOT_IN_USE;
1132                 return FALSE;
1133         }
1134
1135         bt_audio_notify_state(setup, HAL_AUDIO_STARTED);
1136
1137         return TRUE;
1138 }
1139
1140 static gboolean sep_suspend_ind(struct avdtp *session,
1141                                                 struct avdtp_local_sep *sep,
1142                                                 struct avdtp_stream *stream,
1143                                                 uint8_t *err,
1144                                                 void *user_data)
1145 {
1146         struct a2dp_endpoint *endpoint = user_data;
1147         struct a2dp_setup *setup;
1148
1149         DBG("");
1150
1151         setup = find_setup(endpoint->id);
1152         if (!setup) {
1153                 error("Unable to find stream setup for endpoint %u",
1154                                                                 endpoint->id);
1155                 *err = AVDTP_SEP_NOT_IN_USE;
1156                 return FALSE;
1157         }
1158
1159         bt_audio_notify_state(setup, HAL_AUDIO_SUSPEND);
1160
1161         return TRUE;
1162 }
1163
1164 static struct avdtp_sep_ind sep_ind = {
1165         .get_capability         = sep_getcap_ind,
1166         .set_configuration      = sep_setconf_ind,
1167         .open                   = sep_open_ind,
1168         .close                  = sep_close_ind,
1169         .start                  = sep_start_ind,
1170         .suspend                = sep_suspend_ind,
1171 };
1172
1173 static void sep_setconf_cfm(struct avdtp *session, struct avdtp_local_sep *sep,
1174                                 struct avdtp_stream *stream,
1175                                 struct avdtp_error *err, void *user_data)
1176 {
1177         struct a2dp_endpoint *endpoint = user_data;
1178         struct a2dp_setup *setup;
1179         int ret;
1180
1181         DBG("");
1182
1183         setup = find_setup(endpoint->id);
1184         if (!setup) {
1185                 error("Unable to find stream setup for endpoint %u",
1186                                                                 endpoint->id);
1187                 return;
1188         }
1189
1190         if (err)
1191                 goto failed;
1192
1193         ret = avdtp_open(session, stream);
1194         if (ret < 0) {
1195                 error("avdtp_open: %s", strerror(-ret));
1196                 goto failed;
1197         }
1198
1199         return;
1200
1201 failed:
1202         setup_remove(setup);
1203 }
1204
1205 static void sep_open_cfm(struct avdtp *session, struct avdtp_local_sep *sep,
1206                         struct avdtp_stream *stream, struct avdtp_error *err,
1207                         void *user_data)
1208 {
1209         struct a2dp_endpoint *endpoint = user_data;
1210         struct a2dp_device *dev;
1211
1212         DBG("");
1213
1214         if (err)
1215                 goto failed;
1216
1217         dev = find_device_by_session(session);
1218         if (!dev) {
1219                 error("Unable to find device for session");
1220                 goto failed;
1221         }
1222
1223         a2dp_device_connect(dev, transport_connect_cb);
1224
1225         return;
1226
1227 failed:
1228         setup_remove_by_id(endpoint->id);
1229 }
1230
1231 static void sep_start_cfm(struct avdtp *session, struct avdtp_local_sep *sep,
1232                         struct avdtp_stream *stream, struct avdtp_error *err,
1233                         void *user_data)
1234 {
1235         struct a2dp_endpoint *endpoint = user_data;
1236         struct a2dp_setup *setup;
1237
1238         DBG("");
1239
1240         if (err) {
1241                 setup_remove_by_id(endpoint->id);
1242                 return;
1243         }
1244
1245         setup = find_setup(endpoint->id);
1246         if (!setup) {
1247                 error("Unable to find stream setup for %u endpoint",
1248                                                                 endpoint->id);
1249                 return;
1250         }
1251
1252         bt_audio_notify_state(setup, HAL_AUDIO_STARTED);
1253 }
1254
1255 static void sep_suspend_cfm(struct avdtp *session, struct avdtp_local_sep *sep,
1256                         struct avdtp_stream *stream, struct avdtp_error *err,
1257                         void *user_data)
1258 {
1259         struct a2dp_endpoint *endpoint = user_data;
1260         struct a2dp_setup *setup;
1261
1262         DBG("");
1263
1264         if (err) {
1265                 setup_remove_by_id(endpoint->id);
1266                 return;
1267         }
1268
1269         setup = find_setup(endpoint->id);
1270         if (!setup) {
1271                 error("Unable to find stream setup for %u endpoint",
1272                                                                 endpoint->id);
1273                 return;
1274         }
1275
1276         bt_audio_notify_state(setup, HAL_AUDIO_STOPPED);
1277 }
1278
1279 static void sep_close_cfm(struct avdtp *session, struct avdtp_local_sep *sep,
1280                         struct avdtp_stream *stream, struct avdtp_error *err,
1281                         void *user_data)
1282 {
1283         struct a2dp_endpoint *endpoint = user_data;
1284         struct a2dp_setup *setup;
1285
1286         DBG("");
1287
1288         if (err)
1289                 return;
1290
1291         setup = find_setup(endpoint->id);
1292         if (!setup) {
1293                 error("Unable to find stream setup for %u endpoint",
1294                                                                 endpoint->id);
1295                 return;
1296         }
1297
1298         bt_audio_notify_state(setup, HAL_AUDIO_STOPPED);
1299
1300         setup_remove(setup);
1301 }
1302
1303 static void sep_abort_cfm(struct avdtp *session, struct avdtp_local_sep *sep,
1304                         struct avdtp_stream *stream, struct avdtp_error *err,
1305                         void *user_data)
1306 {
1307         struct a2dp_endpoint *endpoint = user_data;
1308
1309         DBG("");
1310
1311         if (err)
1312                 return;
1313
1314         setup_remove_by_id(endpoint->id);
1315 }
1316
1317 static struct avdtp_sep_cfm sep_cfm = {
1318         .set_configuration      = sep_setconf_cfm,
1319         .open                   = sep_open_cfm,
1320         .start                  = sep_start_cfm,
1321         .suspend                = sep_suspend_cfm,
1322         .close                  = sep_close_cfm,
1323         .abort                  = sep_abort_cfm,
1324 };
1325
1326 static uint8_t register_endpoint(const uint8_t *uuid, uint8_t codec,
1327                                                         GSList *presets)
1328 {
1329         struct a2dp_endpoint *endpoint;
1330
1331         /* FIXME: Add proper check for uuid */
1332
1333         endpoint = g_new0(struct a2dp_endpoint, 1);
1334         endpoint->id = g_slist_length(endpoints) + 1;
1335         endpoint->codec = codec;
1336         endpoint->sep = avdtp_register_sep(lseps, AVDTP_SEP_TYPE_SOURCE,
1337                                                 AVDTP_MEDIA_TYPE_AUDIO,
1338                                                 codec, FALSE, &sep_ind,
1339                                                 &sep_cfm, endpoint);
1340         endpoint->caps = presets->data;
1341         endpoint->presets = g_slist_copy(g_slist_nth(presets, 1));
1342
1343         if (endpoint->codec == A2DP_CODEC_VENDOR) {
1344                 a2dp_vendor_codec_t *vndcodec = (void *) endpoint->caps->data;
1345
1346                 avdtp_sep_set_vendor_codec(endpoint->sep,
1347                                                 btohl(vndcodec->vendor_id),
1348                                                 btohs(vndcodec->codec_id));
1349         }
1350
1351         endpoints = g_slist_append(endpoints, endpoint);
1352
1353         return endpoint->id;
1354 }
1355
1356 static GSList *parse_presets(const struct audio_preset *p, uint8_t count,
1357                                                                 uint16_t len)
1358 {
1359         GSList *l = NULL;
1360         uint8_t i;
1361
1362         for (i = 0; count > i; i++) {
1363                 const uint8_t *ptr = (const uint8_t *) p;
1364                 struct a2dp_preset *preset;
1365
1366                 if (len < sizeof(struct audio_preset)) {
1367                         DBG("Invalid preset index %u", i);
1368                         g_slist_free_full(l, preset_free);
1369                         return NULL;
1370                 }
1371
1372                 len -= sizeof(struct audio_preset);
1373                 if (len == 0 || len < p->len) {
1374                         DBG("Invalid preset size of %u for index %u", len, i);
1375                         g_slist_free_full(l, preset_free);
1376                         return NULL;
1377                 }
1378
1379                 preset = g_new0(struct a2dp_preset, 1);
1380                 preset->len = p->len;
1381                 preset->data = g_memdup(p->data, preset->len);
1382                 l = g_slist_append(l, preset);
1383
1384                 len -= preset->len;
1385                 ptr += sizeof(*p) + preset->len;
1386                 p = (const struct audio_preset *) ptr;
1387         }
1388
1389         return l;
1390 }
1391
1392 static void bt_audio_open(const void *buf, uint16_t len)
1393 {
1394         const struct audio_cmd_open *cmd = buf;
1395         struct audio_rsp_open rsp;
1396         GSList *presets;
1397
1398         DBG("");
1399
1400         audio_retrying = false;
1401
1402         if (cmd->presets == 0) {
1403                 error("No audio presets found");
1404                 goto failed;
1405         }
1406
1407         presets = parse_presets(cmd->preset, cmd->presets, len - sizeof(*cmd));
1408         if (!presets) {
1409                 error("No audio presets found");
1410                 goto failed;
1411         }
1412
1413         rsp.id = register_endpoint(cmd->uuid, cmd->codec, presets);
1414         if (rsp.id == 0) {
1415                 g_slist_free_full(presets, preset_free);
1416                 error("Unable to register endpoint");
1417                 goto failed;
1418         }
1419
1420         g_slist_free(presets);
1421
1422         ipc_send_rsp_full(audio_ipc, AUDIO_SERVICE_ID, AUDIO_OP_OPEN,
1423                                                         sizeof(rsp), &rsp, -1);
1424
1425         return;
1426
1427 failed:
1428         ipc_send_rsp(audio_ipc, AUDIO_SERVICE_ID, AUDIO_OP_OPEN,
1429                                                         AUDIO_STATUS_FAILED);
1430 }
1431
1432 static struct a2dp_endpoint *find_endpoint(uint8_t id)
1433 {
1434         GSList *l;
1435
1436         for (l = endpoints; l; l = g_slist_next(l)) {
1437                 struct a2dp_endpoint *endpoint = l->data;
1438
1439                 if (endpoint->id == id)
1440                         return endpoint;
1441         }
1442
1443         return NULL;
1444 }
1445
1446 static void bt_audio_close(const void *buf, uint16_t len)
1447 {
1448         const struct audio_cmd_close *cmd = buf;
1449         struct a2dp_endpoint *endpoint;
1450
1451         DBG("");
1452
1453         endpoint = find_endpoint(cmd->id);
1454         if (!endpoint) {
1455                 error("Unable to find endpoint %u", cmd->id);
1456                 ipc_send_rsp(audio_ipc, AUDIO_SERVICE_ID, AUDIO_OP_CLOSE,
1457                                                         AUDIO_STATUS_FAILED);
1458                 return;
1459         }
1460
1461         endpoints = g_slist_remove(endpoints, endpoint);
1462         unregister_endpoint(endpoint);
1463
1464         ipc_send_rsp(audio_ipc, AUDIO_SERVICE_ID, AUDIO_OP_CLOSE,
1465                                                         AUDIO_STATUS_SUCCESS);
1466 }
1467
1468 static void bt_stream_open(const void *buf, uint16_t len)
1469 {
1470         const struct audio_cmd_open_stream *cmd = buf;
1471         struct audio_rsp_open_stream *rsp;
1472         struct a2dp_setup *setup;
1473         int fd;
1474         uint16_t omtu;
1475
1476         DBG("");
1477
1478         if (cmd->id)
1479                 setup = find_setup(cmd->id);
1480         else
1481                 setup = setups ? setups->data : NULL;
1482         if (!setup) {
1483                 error("Unable to find stream for endpoint %u", cmd->id);
1484                 ipc_send_rsp(audio_ipc, AUDIO_SERVICE_ID, AUDIO_OP_OPEN_STREAM,
1485                                                         AUDIO_STATUS_FAILED);
1486                 return;
1487         }
1488
1489         if (!avdtp_stream_get_transport(setup->stream, &fd, NULL, &omtu,
1490                                                                 NULL)) {
1491                 error("avdtp_stream_get_transport: failed");
1492                 ipc_send_rsp(audio_ipc, AUDIO_SERVICE_ID, AUDIO_OP_OPEN_STREAM,
1493                                                         AUDIO_STATUS_FAILED);
1494                 return;
1495         }
1496
1497         len = sizeof(struct audio_rsp_open_stream) +
1498                         sizeof(struct audio_preset) + setup->preset->len;
1499         rsp = g_malloc0(len);
1500         rsp->id = setup->endpoint->id;
1501         rsp->mtu = omtu;
1502         rsp->preset->len = setup->preset->len;
1503         memcpy(rsp->preset->data, setup->preset->data, setup->preset->len);
1504
1505         ipc_send_rsp_full(audio_ipc, AUDIO_SERVICE_ID, AUDIO_OP_OPEN_STREAM,
1506                                                                 len, rsp, fd);
1507
1508         g_free(rsp);
1509 }
1510
1511 static void bt_stream_close(const void *buf, uint16_t len)
1512 {
1513         const struct audio_cmd_close_stream *cmd = buf;
1514         struct a2dp_setup *setup;
1515         int err;
1516
1517         DBG("");
1518
1519         setup = find_setup(cmd->id);
1520         if (!setup) {
1521                 error("Unable to find stream for endpoint %u", cmd->id);
1522                 goto failed;
1523         }
1524
1525         err = avdtp_close(setup->dev->session, setup->stream, FALSE);
1526         if (err < 0) {
1527                 error("avdtp_close: %s", strerror(-err));
1528                 goto failed;
1529         }
1530
1531         ipc_send_rsp(audio_ipc, AUDIO_SERVICE_ID, AUDIO_OP_CLOSE_STREAM,
1532                                                         AUDIO_STATUS_SUCCESS);
1533
1534         return;
1535
1536 failed:
1537         ipc_send_rsp(audio_ipc, AUDIO_SERVICE_ID, AUDIO_OP_CLOSE_STREAM,
1538                                                         AUDIO_STATUS_FAILED);
1539 }
1540
1541 static void bt_stream_resume(const void *buf, uint16_t len)
1542 {
1543         const struct audio_cmd_resume_stream *cmd = buf;
1544         struct a2dp_setup *setup;
1545         int err;
1546
1547         DBG("");
1548
1549         setup = find_setup(cmd->id);
1550         if (!setup) {
1551                 error("Unable to find stream for endpoint %u", cmd->id);
1552                 goto failed;
1553         }
1554
1555         if (setup->state != HAL_AUDIO_STARTED) {
1556                 err = avdtp_start(setup->dev->session, setup->stream);
1557                 if (err < 0) {
1558                         error("avdtp_start: %s", strerror(-err));
1559                         goto failed;
1560                 }
1561         }
1562
1563         ipc_send_rsp(audio_ipc, AUDIO_SERVICE_ID, AUDIO_OP_RESUME_STREAM,
1564                                                         AUDIO_STATUS_SUCCESS);
1565
1566         return;
1567
1568 failed:
1569         ipc_send_rsp(audio_ipc, AUDIO_SERVICE_ID, AUDIO_OP_RESUME_STREAM,
1570                                                         AUDIO_STATUS_FAILED);
1571 }
1572
1573 static void bt_stream_suspend(const void *buf, uint16_t len)
1574 {
1575         const struct audio_cmd_suspend_stream *cmd = buf;
1576         struct a2dp_setup *setup;
1577         int err;
1578
1579         DBG("");
1580
1581         setup = find_setup(cmd->id);
1582         if (!setup) {
1583                 error("Unable to find stream for endpoint %u", cmd->id);
1584                 goto failed;
1585         }
1586
1587         err = avdtp_suspend(setup->dev->session, setup->stream);
1588         if (err < 0) {
1589                 error("avdtp_suspend: %s", strerror(-err));
1590                 goto failed;
1591         }
1592
1593         ipc_send_rsp(audio_ipc, AUDIO_SERVICE_ID, AUDIO_OP_SUSPEND_STREAM,
1594                                                         AUDIO_STATUS_SUCCESS);
1595
1596         return;
1597
1598 failed:
1599         ipc_send_rsp(audio_ipc, AUDIO_SERVICE_ID, AUDIO_OP_SUSPEND_STREAM,
1600                                                         AUDIO_STATUS_FAILED);
1601 }
1602
1603 static const struct ipc_handler audio_handlers[] = {
1604         /* AUDIO_OP_OPEN */
1605         { bt_audio_open, true, sizeof(struct audio_cmd_open) },
1606         /* AUDIO_OP_CLOSE */
1607         { bt_audio_close, false, sizeof(struct audio_cmd_close) },
1608         /* AUDIO_OP_OPEN_STREAM */
1609         { bt_stream_open, false, sizeof(struct audio_cmd_open_stream) },
1610         /* AUDIO_OP_CLOSE_STREAM */
1611         { bt_stream_close, false, sizeof(struct audio_cmd_close_stream) },
1612         /* AUDIO_OP_RESUME_STREAM */
1613         { bt_stream_resume, false, sizeof(struct audio_cmd_resume_stream) },
1614         /* AUDIO_OP_SUSPEND_STREAM */
1615         { bt_stream_suspend, false, sizeof(struct audio_cmd_suspend_stream) },
1616 };
1617
1618 static void bt_audio_unregister(void)
1619 {
1620         DBG("");
1621
1622         if (audio_retry_id > 0)
1623                 g_source_remove(audio_retry_id);
1624
1625         g_slist_free_full(endpoints, unregister_endpoint);
1626         endpoints = NULL;
1627
1628         g_slist_free_full(setups, setup_free);
1629         setups = NULL;
1630
1631         ipc_cleanup(audio_ipc);
1632         audio_ipc = NULL;
1633
1634         queue_destroy(lseps, NULL);
1635 }
1636
1637 static bool bt_audio_register(ipc_disconnect_cb disconnect)
1638 {
1639         DBG("");
1640
1641         audio_ipc = ipc_init(BLUEZ_AUDIO_SK_PATH, sizeof(BLUEZ_AUDIO_SK_PATH),
1642                                 AUDIO_SERVICE_ID_MAX, false, disconnect, NULL);
1643         if (!audio_ipc)
1644                 return false;
1645
1646         ipc_register(audio_ipc, AUDIO_SERVICE_ID, audio_handlers,
1647                                                 G_N_ELEMENTS(audio_handlers));
1648
1649         return true;
1650 }
1651
1652 static gboolean audio_retry_register(void *data)
1653 {
1654         ipc_disconnect_cb cb = data;
1655
1656         audio_retry_id = 0;
1657         audio_retrying = true;
1658
1659         bt_audio_register(cb);
1660
1661         return FALSE;
1662 }
1663
1664 static void audio_disconnected(void *data)
1665 {
1666         GSList *l;
1667         bool restart;
1668
1669         DBG("");
1670
1671         if (audio_retrying)
1672                 goto retry;
1673
1674         restart = endpoints != NULL ? true : false;
1675
1676         bt_audio_unregister();
1677
1678         for (l = devices; l; l = g_slist_next(l)) {
1679                 struct a2dp_device *dev = l->data;
1680
1681                 avdtp_shutdown(dev->session);
1682         }
1683
1684         if (!restart)
1685                 return;
1686
1687 retry:
1688         audio_retry_id = g_timeout_add_seconds(AUDIO_RETRY_TIMEOUT,
1689                                                 audio_retry_register,
1690                                                 audio_disconnected);
1691 }
1692
1693 bool bt_a2dp_register(struct ipc *ipc, const bdaddr_t *addr, uint8_t mode)
1694 {
1695         GError *err = NULL;
1696         sdp_record_t *rec;
1697
1698         DBG("");
1699
1700         bacpy(&adapter_addr, addr);
1701
1702         lseps = queue_new();
1703
1704         server = bt_io_listen(connect_cb, NULL, NULL, NULL, &err,
1705                                 BT_IO_OPT_SOURCE_BDADDR, &adapter_addr,
1706                                 BT_IO_OPT_PSM, AVDTP_PSM,
1707                                 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_MEDIUM,
1708                                 BT_IO_OPT_MASTER, true,
1709                                 BT_IO_OPT_INVALID);
1710         if (!server) {
1711                 error("Failed to listen on AVDTP channel: %s", err->message);
1712                 g_error_free(err);
1713                 return false;
1714         }
1715
1716         rec = a2dp_record();
1717         if (!rec) {
1718                 error("Failed to allocate A2DP record");
1719                 goto fail;
1720         }
1721
1722         if (bt_adapter_add_record(rec, SVC_HINT_CAPTURING) < 0) {
1723                 error("Failed to register A2DP record");
1724                 sdp_record_free(rec);
1725                 goto fail;
1726         }
1727         record_id = rec->handle;
1728
1729         hal_ipc = ipc;
1730
1731         ipc_register(hal_ipc, HAL_SERVICE_ID_A2DP, cmd_handlers,
1732                                                 G_N_ELEMENTS(cmd_handlers));
1733
1734         if (bt_audio_register(audio_disconnected))
1735                 return true;
1736
1737 fail:
1738         g_io_channel_shutdown(server, TRUE, NULL);
1739         g_io_channel_unref(server);
1740         server = NULL;
1741         return false;
1742 }
1743
1744 void bt_a2dp_unregister(void)
1745 {
1746         DBG("");
1747
1748         g_slist_free_full(setups, setup_free);
1749         setups = NULL;
1750
1751         g_slist_free_full(endpoints, unregister_endpoint);
1752         endpoints = NULL;
1753
1754         g_slist_free_full(devices, a2dp_device_free);
1755         devices = NULL;
1756
1757         ipc_unregister(hal_ipc, HAL_SERVICE_ID_A2DP);
1758         hal_ipc = NULL;
1759
1760         bt_adapter_remove_record(record_id);
1761         record_id = 0;
1762
1763         if (server) {
1764                 g_io_channel_shutdown(server, TRUE, NULL);
1765                 g_io_channel_unref(server);
1766                 server = NULL;
1767         }
1768
1769         if (audio_ipc) {
1770                 ipc_unregister(audio_ipc, AUDIO_SERVICE_ID);
1771                 ipc_cleanup(audio_ipc);
1772                 audio_ipc = NULL;
1773         }
1774 }