1/* 2 * 3 * BlueZ - Bluetooth protocol stack for Linux 4 * 5 * Copyright (C) 2006-2010 Nokia Corporation 6 * Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org> 7 * 8 * 9 * This library is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU Lesser General Public 11 * License as published by the Free Software Foundation; either 12 * version 2.1 of the License, or (at your option) any later version. 13 * 14 * This library is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * Lesser General Public License for more details. 18 * 19 * You should have received a copy of the GNU Lesser General Public 20 * License along with this library; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 22 * 23 */ 24 25#ifdef HAVE_CONFIG_H 26#include <config.h> 27#endif 28 29#include <stdint.h> 30#include <sys/socket.h> 31#include <sys/un.h> 32#include <time.h> 33#include <sys/time.h> 34#include <pthread.h> 35#include <signal.h> 36#include <limits.h> 37 38#include <netinet/in.h> 39 40#include <alsa/asoundlib.h> 41#include <alsa/pcm_external.h> 42 43#include "ipc.h" 44#include "sbc.h" 45#include "rtp.h" 46 47/* #define ENABLE_DEBUG */ 48 49#define UINT_SECS_MAX (UINT_MAX / 1000000 - 1) 50 51#define MIN_PERIOD_TIME 1 52 53#define BUFFER_SIZE 2048 54 55#ifdef ENABLE_DEBUG 56#define DBG(fmt, arg...) printf("DEBUG: %s: " fmt "\n" , __FUNCTION__ , ## arg) 57#else 58#define DBG(fmt, arg...) 59#endif 60 61#ifndef SOL_SCO 62#define SOL_SCO 17 63#endif 64 65#ifndef SCO_TXBUFS 66#define SCO_TXBUFS 0x03 67#endif 68 69#ifndef SCO_RXBUFS 70#define SCO_RXBUFS 0x04 71#endif 72 73#ifndef MIN 74# define MIN(x, y) ((x) < (y) ? (x) : (y)) 75#endif 76 77#ifndef MAX 78# define MAX(x, y) ((x) > (y) ? (x) : (y)) 79#endif 80 81#define MAX_BITPOOL 64 82#define MIN_BITPOOL 2 83 84/* adapted from glibc sys/time.h timersub() macro */ 85#define priv_timespecsub(a, b, result) \ 86 do { \ 87 (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \ 88 (result)->tv_nsec = (a)->tv_nsec - (b)->tv_nsec; \ 89 if ((result)->tv_nsec < 0) { \ 90 --(result)->tv_sec; \ 91 (result)->tv_nsec += 1000000000; \ 92 } \ 93 } while (0) 94 95struct bluetooth_a2dp { 96 sbc_capabilities_t sbc_capabilities; 97 sbc_t sbc; /* Codec data */ 98 int sbc_initialized; /* Keep track if the encoder is initialized */ 99 unsigned int codesize; /* SBC codesize */ 100 int samples; /* Number of encoded samples */ 101 uint8_t buffer[BUFFER_SIZE]; /* Codec transfer buffer */ 102 unsigned int count; /* Codec transfer buffer counter */ 103 104 int nsamples; /* Cumulative number of codec samples */ 105 uint16_t seq_num; /* Cumulative packet sequence */ 106 int frame_count; /* Current frames in buffer*/ 107}; 108 109struct bluetooth_alsa_config { 110 char device[18]; /* Address of the remote Device */ 111 int has_device; 112 uint8_t transport; /* Requested transport */ 113 int has_transport; 114 uint16_t rate; 115 int has_rate; 116 uint8_t channel_mode; /* A2DP only */ 117 int has_channel_mode; 118 uint8_t allocation_method; /* A2DP only */ 119 int has_allocation_method; 120 uint8_t subbands; /* A2DP only */ 121 int has_subbands; 122 uint8_t block_length; /* A2DP only */ 123 int has_block_length; 124 uint8_t bitpool; /* A2DP only */ 125 int has_bitpool; 126 int autoconnect; 127}; 128 129struct bluetooth_data { 130 snd_pcm_ioplug_t io; 131 struct bluetooth_alsa_config alsa_config; /* ALSA resource file parameters */ 132 volatile snd_pcm_sframes_t hw_ptr; 133 int transport; /* chosen transport SCO or AD2P */ 134 unsigned int link_mtu; /* MTU for selected transport channel */ 135 volatile struct pollfd stream; /* Audio stream filedescriptor */ 136 struct pollfd server; /* Audio daemon filedescriptor */ 137 uint8_t buffer[BUFFER_SIZE]; /* Encoded transfer buffer */ 138 unsigned int count; /* Transfer buffer counter */ 139 struct bluetooth_a2dp a2dp; /* A2DP data */ 140 141 pthread_t hw_thread; /* Makes virtual hw pointer move */ 142 int pipefd[2]; /* Inter thread communication */ 143 int stopped; 144 sig_atomic_t reset; /* Request XRUN handling */ 145}; 146 147static int audioservice_send(int sk, const bt_audio_msg_header_t *msg); 148static int audioservice_expect(int sk, bt_audio_msg_header_t *outmsg, 149 int expected_type); 150 151static int bluetooth_start(snd_pcm_ioplug_t *io) 152{ 153 DBG("bluetooth_start %p", io); 154 155 return 0; 156} 157 158static int bluetooth_stop(snd_pcm_ioplug_t *io) 159{ 160 DBG("bluetooth_stop %p", io); 161 162 return 0; 163} 164 165static void *playback_hw_thread(void *param) 166{ 167 struct bluetooth_data *data = param; 168 unsigned int prev_periods; 169 double period_time; 170 struct timespec start; 171 struct pollfd fds[2]; 172 int poll_timeout; 173 174 data->server.events = POLLIN; 175 /* note: only errors for data->stream.events */ 176 177 fds[0] = data->server; 178 fds[1] = data->stream; 179 180 prev_periods = 0; 181 period_time = 1000000.0 * data->io.period_size / data->io.rate; 182 if (period_time > (int) (MIN_PERIOD_TIME * 1000)) 183 poll_timeout = (int) (period_time / 1000.0f); 184 else 185 poll_timeout = MIN_PERIOD_TIME; 186 187 clock_gettime(CLOCK_MONOTONIC, &start); 188 189 while (1) { 190 unsigned int dtime, periods; 191 struct timespec cur, delta; 192 int ret; 193 194 if (data->stopped) 195 goto iter_sleep; 196 197 if (data->reset) { 198 DBG("Handle XRUN in hw-thread."); 199 data->reset = 0; 200 clock_gettime(CLOCK_MONOTONIC, &start); 201 prev_periods = 0; 202 } 203 204 clock_gettime(CLOCK_MONOTONIC, &cur); 205 206 priv_timespecsub(&cur, &start, &delta); 207 208 dtime = delta.tv_sec * 1000000 + delta.tv_nsec / 1000; 209 periods = 1.0 * dtime / period_time; 210 211 if (periods > prev_periods) { 212 char c = 'w'; 213 int frags = periods - prev_periods, n; 214 215 data->hw_ptr += frags * data->io.period_size; 216 data->hw_ptr %= data->io.buffer_size; 217 218 for (n = 0; n < frags; n++) { 219 /* Notify user that hardware pointer 220 * has moved * */ 221 if (write(data->pipefd[1], &c, 1) < 0) 222 pthread_testcancel(); 223 } 224 225 /* Reset point of reference to avoid too big values 226 * that wont fit an unsigned int */ 227 if ((unsigned int) delta.tv_sec < UINT_SECS_MAX) 228 prev_periods = periods; 229 else { 230 prev_periods = 0; 231 clock_gettime(CLOCK_MONOTONIC, &start); 232 } 233 } 234 235iter_sleep: 236 /* sleep up to one period interval */ 237 ret = poll(fds, 2, poll_timeout); 238 239 if (ret < 0) { 240 if (errno != EINTR) { 241 SNDERR("poll error: %s (%d)", strerror(errno), 242 errno); 243 break; 244 } 245 } else if (ret > 0) { 246 ret = (fds[0].revents) ? 0 : 1; 247 SNDERR("poll fd %d revents %d", ret, fds[ret].revents); 248 if (fds[ret].revents & (POLLERR | POLLHUP | POLLNVAL)) 249 break; 250 } 251 252 /* Offer opportunity to be canceled by main thread */ 253 pthread_testcancel(); 254 } 255 256 data->hw_thread = 0; 257 pthread_exit(NULL); 258} 259 260static int bluetooth_playback_start(snd_pcm_ioplug_t *io) 261{ 262 struct bluetooth_data *data = io->private_data; 263 int err; 264 265 DBG("%p", io); 266 267 data->stopped = 0; 268 269 if (data->hw_thread) 270 return 0; 271 272 err = pthread_create(&data->hw_thread, 0, playback_hw_thread, data); 273 274 return -err; 275} 276 277static int bluetooth_playback_stop(snd_pcm_ioplug_t *io) 278{ 279 struct bluetooth_data *data = io->private_data; 280 281 DBG("%p", io); 282 283 data->stopped = 1; 284 285 return 0; 286} 287 288static snd_pcm_sframes_t bluetooth_pointer(snd_pcm_ioplug_t *io) 289{ 290 struct bluetooth_data *data = io->private_data; 291 292 return data->hw_ptr; 293} 294 295static void bluetooth_exit(struct bluetooth_data *data) 296{ 297 struct bluetooth_a2dp *a2dp = &data->a2dp; 298 299 if (data->server.fd >= 0) 300 bt_audio_service_close(data->server.fd); 301 302 if (data->stream.fd >= 0) 303 close(data->stream.fd); 304 305 if (data->hw_thread) { 306 pthread_cancel(data->hw_thread); 307 pthread_join(data->hw_thread, 0); 308 } 309 310 if (a2dp->sbc_initialized) 311 sbc_finish(&a2dp->sbc); 312 313 if (data->pipefd[0] > 0) 314 close(data->pipefd[0]); 315 316 if (data->pipefd[1] > 0) 317 close(data->pipefd[1]); 318 319 free(data); 320} 321 322static int bluetooth_close(snd_pcm_ioplug_t *io) 323{ 324 struct bluetooth_data *data = io->private_data; 325 326 DBG("%p", io); 327 328 bluetooth_exit(data); 329 330 return 0; 331} 332 333static int bluetooth_prepare(snd_pcm_ioplug_t *io) 334{ 335 struct bluetooth_data *data = io->private_data; 336 char c = 'w'; 337 char buf[BT_SUGGESTED_BUFFER_SIZE]; 338 struct bt_start_stream_req *req = (void *) buf; 339 struct bt_start_stream_rsp *rsp = (void *) buf; 340 struct bt_new_stream_ind *ind = (void *) buf; 341 uint32_t period_count = io->buffer_size / io->period_size; 342 int opt_name, err; 343 struct timeval t = { 0, period_count }; 344 345 DBG("Preparing with io->period_size=%lu io->buffer_size=%lu", 346 io->period_size, io->buffer_size); 347 348 data->reset = 0; 349 350 /* As we're gonna receive messages on the server socket, we have to stop the 351 hw thread that is polling on it, if any */ 352 if (data->hw_thread) { 353 pthread_cancel(data->hw_thread); 354 pthread_join(data->hw_thread, 0); 355 data->hw_thread = 0; 356 } 357 358 if (io->stream == SND_PCM_STREAM_PLAYBACK) 359 /* If not null for playback, xmms doesn't display time 360 * correctly */ 361 data->hw_ptr = 0; 362 else 363 /* ALSA library is really picky on the fact hw_ptr is not null. 364 * If it is, capture won't start */ 365 data->hw_ptr = io->period_size; 366 367 /* send start */ 368 memset(req, 0, BT_SUGGESTED_BUFFER_SIZE); 369 req->h.type = BT_REQUEST; 370 req->h.name = BT_START_STREAM; 371 req->h.length = sizeof(*req); 372 373 err = audioservice_send(data->server.fd, &req->h); 374 if (err < 0) 375 return err; 376 377 rsp->h.length = sizeof(*rsp); 378 err = audioservice_expect(data->server.fd, &rsp->h, 379 BT_START_STREAM); 380 if (err < 0) 381 return err; 382 383 ind->h.length = sizeof(*ind); 384 err = audioservice_expect(data->server.fd, &ind->h, 385 BT_NEW_STREAM); 386 if (err < 0) 387 return err; 388 389 if (data->stream.fd >= 0) 390 close(data->stream.fd); 391 392 data->stream.fd = bt_audio_service_get_data_fd(data->server.fd); 393 if (data->stream.fd < 0) { 394 return -errno; 395 } 396 397 if (data->transport == BT_CAPABILITIES_TRANSPORT_A2DP) { 398 opt_name = (io->stream == SND_PCM_STREAM_PLAYBACK) ? 399 SO_SNDTIMEO : SO_RCVTIMEO; 400 401 if (setsockopt(data->stream.fd, SOL_SOCKET, opt_name, &t, 402 sizeof(t)) < 0) 403 return -errno; 404 } else { 405 opt_name = (io->stream == SND_PCM_STREAM_PLAYBACK) ? 406 SCO_TXBUFS : SCO_RXBUFS; 407 408 if (setsockopt(data->stream.fd, SOL_SCO, opt_name, &period_count, 409 sizeof(period_count)) == 0) 410 return 0; 411 412 opt_name = (io->stream == SND_PCM_STREAM_PLAYBACK) ? 413 SO_SNDBUF : SO_RCVBUF; 414 415 if (setsockopt(data->stream.fd, SOL_SCO, opt_name, &period_count, 416 sizeof(period_count)) == 0) 417 return 0; 418 419 /* FIXME : handle error codes */ 420 } 421 422 /* wake up any client polling at us */ 423 err = write(data->pipefd[1], &c, 1); 424 if (err < 0) 425 return err; 426 427 return 0; 428} 429 430static int bluetooth_hsp_hw_params(snd_pcm_ioplug_t *io, 431 snd_pcm_hw_params_t *params) 432{ 433 struct bluetooth_data *data = io->private_data; 434 char buf[BT_SUGGESTED_BUFFER_SIZE]; 435 struct bt_open_req *open_req = (void *) buf; 436 struct bt_open_rsp *open_rsp = (void *) buf; 437 struct bt_set_configuration_req *req = (void *) buf; 438 struct bt_set_configuration_rsp *rsp = (void *) buf; 439 int err; 440 441 DBG("Preparing with io->period_size=%lu io->buffer_size=%lu", 442 io->period_size, io->buffer_size); 443 444 memset(req, 0, BT_SUGGESTED_BUFFER_SIZE); 445 open_req->h.type = BT_REQUEST; 446 open_req->h.name = BT_OPEN; 447 open_req->h.length = sizeof(*open_req); 448 449 strncpy(open_req->destination, data->alsa_config.device, 18); 450 open_req->seid = BT_A2DP_SEID_RANGE + 1; 451 open_req->lock = (io->stream == SND_PCM_STREAM_PLAYBACK ? 452 BT_WRITE_LOCK : BT_READ_LOCK); 453 454 err = audioservice_send(data->server.fd, &open_req->h); 455 if (err < 0) 456 return err; 457 458 open_rsp->h.length = sizeof(*open_rsp); 459 err = audioservice_expect(data->server.fd, &open_rsp->h, 460 BT_OPEN); 461 if (err < 0) 462 return err; 463 464 memset(req, 0, BT_SUGGESTED_BUFFER_SIZE); 465 req->h.type = BT_REQUEST; 466 req->h.name = BT_SET_CONFIGURATION; 467 req->h.length = sizeof(*req); 468 469 req->codec.transport = BT_CAPABILITIES_TRANSPORT_SCO; 470 req->codec.seid = BT_A2DP_SEID_RANGE + 1; 471 req->codec.length = sizeof(pcm_capabilities_t); 472 473 req->h.length += req->codec.length - sizeof(req->codec); 474 err = audioservice_send(data->server.fd, &req->h); 475 if (err < 0) 476 return err; 477 478 rsp->h.length = sizeof(*rsp); 479 err = audioservice_expect(data->server.fd, &rsp->h, 480 BT_SET_CONFIGURATION); 481 if (err < 0) 482 return err; 483 484 data->transport = BT_CAPABILITIES_TRANSPORT_SCO; 485 data->link_mtu = rsp->link_mtu; 486 487 return 0; 488} 489 490static uint8_t default_bitpool(uint8_t freq, uint8_t mode) 491{ 492 switch (freq) { 493 case BT_SBC_SAMPLING_FREQ_16000: 494 case BT_SBC_SAMPLING_FREQ_32000: 495 return 53; 496 case BT_SBC_SAMPLING_FREQ_44100: 497 switch (mode) { 498 case BT_A2DP_CHANNEL_MODE_MONO: 499 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL: 500 return 31; 501 case BT_A2DP_CHANNEL_MODE_STEREO: 502 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO: 503 return 53; 504 default: 505 DBG("Invalid channel mode %u", mode); 506 return 53; 507 } 508 case BT_SBC_SAMPLING_FREQ_48000: 509 switch (mode) { 510 case BT_A2DP_CHANNEL_MODE_MONO: 511 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL: 512 return 29; 513 case BT_A2DP_CHANNEL_MODE_STEREO: 514 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO: 515 return 51; 516 default: 517 DBG("Invalid channel mode %u", mode); 518 return 51; 519 } 520 default: 521 DBG("Invalid sampling freq %u", freq); 522 return 53; 523 } 524} 525 526static int bluetooth_a2dp_init(struct bluetooth_data *data, 527 snd_pcm_hw_params_t *params) 528{ 529 struct bluetooth_alsa_config *cfg = &data->alsa_config; 530 sbc_capabilities_t *cap = &data->a2dp.sbc_capabilities; 531 unsigned int max_bitpool, min_bitpool, rate, channels; 532 int dir; 533 534 snd_pcm_hw_params_get_rate(params, &rate, &dir); 535 snd_pcm_hw_params_get_channels(params, &channels); 536 537 switch (rate) { 538 case 48000: 539 cap->frequency = BT_SBC_SAMPLING_FREQ_48000; 540 break; 541 case 44100: 542 cap->frequency = BT_SBC_SAMPLING_FREQ_44100; 543 break; 544 case 32000: 545 cap->frequency = BT_SBC_SAMPLING_FREQ_32000; 546 break; 547 case 16000: 548 cap->frequency = BT_SBC_SAMPLING_FREQ_16000; 549 break; 550 default: 551 DBG("Rate %d not supported", rate); 552 return -1; 553 } 554 555 if (cfg->has_channel_mode) 556 cap->channel_mode = cfg->channel_mode; 557 else if (channels == 2) { 558 if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO) 559 cap->channel_mode = BT_A2DP_CHANNEL_MODE_JOINT_STEREO; 560 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) 561 cap->channel_mode = BT_A2DP_CHANNEL_MODE_STEREO; 562 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) 563 cap->channel_mode = BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL; 564 } else { 565 if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) 566 cap->channel_mode = BT_A2DP_CHANNEL_MODE_MONO; 567 } 568 569 if (!cap->channel_mode) { 570 DBG("No supported channel modes"); 571 return -1; 572 } 573 574 if (cfg->has_block_length) 575 cap->block_length = cfg->block_length; 576 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_16) 577 cap->block_length = BT_A2DP_BLOCK_LENGTH_16; 578 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_12) 579 cap->block_length = BT_A2DP_BLOCK_LENGTH_12; 580 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_8) 581 cap->block_length = BT_A2DP_BLOCK_LENGTH_8; 582 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_4) 583 cap->block_length = BT_A2DP_BLOCK_LENGTH_4; 584 else { 585 DBG("No supported block lengths"); 586 return -1; 587 } 588 589 if (cfg->has_subbands) 590 cap->subbands = cfg->subbands; 591 if (cap->subbands & BT_A2DP_SUBBANDS_8) 592 cap->subbands = BT_A2DP_SUBBANDS_8; 593 else if (cap->subbands & BT_A2DP_SUBBANDS_4) 594 cap->subbands = BT_A2DP_SUBBANDS_4; 595 else { 596 DBG("No supported subbands"); 597 return -1; 598 } 599 600 if (cfg->has_allocation_method) 601 cap->allocation_method = cfg->allocation_method; 602 if (cap->allocation_method & BT_A2DP_ALLOCATION_LOUDNESS) 603 cap->allocation_method = BT_A2DP_ALLOCATION_LOUDNESS; 604 else if (cap->allocation_method & BT_A2DP_ALLOCATION_SNR) 605 cap->allocation_method = BT_A2DP_ALLOCATION_SNR; 606 607 if (cfg->has_bitpool) 608 min_bitpool = max_bitpool = cfg->bitpool; 609 else { 610 min_bitpool = MAX(MIN_BITPOOL, cap->min_bitpool); 611 max_bitpool = MIN(default_bitpool(cap->frequency, 612 cap->channel_mode), 613 cap->max_bitpool); 614 } 615 616 cap->min_bitpool = min_bitpool; 617 cap->max_bitpool = max_bitpool; 618 619 return 0; 620} 621 622static void bluetooth_a2dp_setup(struct bluetooth_a2dp *a2dp) 623{ 624 sbc_capabilities_t active_capabilities = a2dp->sbc_capabilities; 625 626 if (a2dp->sbc_initialized) 627 sbc_reinit(&a2dp->sbc, 0); 628 else 629 sbc_init(&a2dp->sbc, 0); 630 a2dp->sbc_initialized = 1; 631 632 if (active_capabilities.frequency & BT_SBC_SAMPLING_FREQ_16000) 633 a2dp->sbc.frequency = SBC_FREQ_16000; 634 635 if (active_capabilities.frequency & BT_SBC_SAMPLING_FREQ_32000) 636 a2dp->sbc.frequency = SBC_FREQ_32000; 637 638 if (active_capabilities.frequency & BT_SBC_SAMPLING_FREQ_44100) 639 a2dp->sbc.frequency = SBC_FREQ_44100; 640 641 if (active_capabilities.frequency & BT_SBC_SAMPLING_FREQ_48000) 642 a2dp->sbc.frequency = SBC_FREQ_48000; 643 644 if (active_capabilities.channel_mode & BT_A2DP_CHANNEL_MODE_MONO) 645 a2dp->sbc.mode = SBC_MODE_MONO; 646 647 if (active_capabilities.channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) 648 a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL; 649 650 if (active_capabilities.channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) 651 a2dp->sbc.mode = SBC_MODE_STEREO; 652 653 if (active_capabilities.channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO) 654 a2dp->sbc.mode = SBC_MODE_JOINT_STEREO; 655 656 a2dp->sbc.allocation = active_capabilities.allocation_method 657 == BT_A2DP_ALLOCATION_SNR ? SBC_AM_SNR 658 : SBC_AM_LOUDNESS; 659 660 switch (active_capabilities.subbands) { 661 case BT_A2DP_SUBBANDS_4: 662 a2dp->sbc.subbands = SBC_SB_4; 663 break; 664 case BT_A2DP_SUBBANDS_8: 665 a2dp->sbc.subbands = SBC_SB_8; 666 break; 667 } 668 669 switch (active_capabilities.block_length) { 670 case BT_A2DP_BLOCK_LENGTH_4: 671 a2dp->sbc.blocks = SBC_BLK_4; 672 break; 673 case BT_A2DP_BLOCK_LENGTH_8: 674 a2dp->sbc.blocks = SBC_BLK_8; 675 break; 676 case BT_A2DP_BLOCK_LENGTH_12: 677 a2dp->sbc.blocks = SBC_BLK_12; 678 break; 679 case BT_A2DP_BLOCK_LENGTH_16: 680 a2dp->sbc.blocks = SBC_BLK_16; 681 break; 682 } 683 684 a2dp->sbc.bitpool = active_capabilities.max_bitpool; 685 a2dp->codesize = sbc_get_codesize(&a2dp->sbc); 686 a2dp->count = sizeof(struct rtp_header) + sizeof(struct rtp_payload); 687} 688 689static int bluetooth_a2dp_hw_params(snd_pcm_ioplug_t *io, 690 snd_pcm_hw_params_t *params) 691{ 692 struct bluetooth_data *data = io->private_data; 693 struct bluetooth_a2dp *a2dp = &data->a2dp; 694 char buf[BT_SUGGESTED_BUFFER_SIZE]; 695 struct bt_open_req *open_req = (void *) buf; 696 struct bt_open_rsp *open_rsp = (void *) buf; 697 struct bt_set_configuration_req *req = (void *) buf; 698 struct bt_set_configuration_rsp *rsp = (void *) buf; 699 int err; 700 701 DBG("Preparing with io->period_size=%lu io->buffer_size=%lu", 702 io->period_size, io->buffer_size); 703 704 memset(req, 0, BT_SUGGESTED_BUFFER_SIZE); 705 open_req->h.type = BT_REQUEST; 706 open_req->h.name = BT_OPEN; 707 open_req->h.length = sizeof(*open_req); 708 709 strncpy(open_req->destination, data->alsa_config.device, 18); 710 open_req->seid = a2dp->sbc_capabilities.capability.seid; 711 open_req->lock = (io->stream == SND_PCM_STREAM_PLAYBACK ? 712 BT_WRITE_LOCK : BT_READ_LOCK); 713 714 err = audioservice_send(data->server.fd, &open_req->h); 715 if (err < 0) 716 return err; 717 718 open_rsp->h.length = sizeof(*open_rsp); 719 err = audioservice_expect(data->server.fd, &open_rsp->h, 720 BT_OPEN); 721 if (err < 0) 722 return err; 723 724 err = bluetooth_a2dp_init(data, params); 725 if (err < 0) 726 return err; 727 728 memset(req, 0, BT_SUGGESTED_BUFFER_SIZE); 729 req->h.type = BT_REQUEST; 730 req->h.name = BT_SET_CONFIGURATION; 731 req->h.length = sizeof(*req); 732 733 memcpy(&req->codec, &a2dp->sbc_capabilities, 734 sizeof(a2dp->sbc_capabilities)); 735 736 req->codec.transport = BT_CAPABILITIES_TRANSPORT_A2DP; 737 req->codec.length = sizeof(a2dp->sbc_capabilities); 738 req->h.length += req->codec.length - sizeof(req->codec); 739 740 err = audioservice_send(data->server.fd, &req->h); 741 if (err < 0) 742 return err; 743 744 rsp->h.length = sizeof(*rsp); 745 err = audioservice_expect(data->server.fd, &rsp->h, 746 BT_SET_CONFIGURATION); 747 if (err < 0) 748 return err; 749 750 data->transport = BT_CAPABILITIES_TRANSPORT_A2DP; 751 data->link_mtu = rsp->link_mtu; 752 753 /* Setup SBC encoder now we agree on parameters */ 754 bluetooth_a2dp_setup(a2dp); 755 756 DBG("\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n", 757 a2dp->sbc.allocation, a2dp->sbc.subbands, a2dp->sbc.blocks, 758 a2dp->sbc.bitpool); 759 760 return 0; 761} 762 763static int bluetooth_poll_descriptors(snd_pcm_ioplug_t *io, 764 struct pollfd *pfd, unsigned int space) 765{ 766 struct bluetooth_data *data = io->private_data; 767 768 assert(io); 769 770 if (space < 1) 771 return 0; 772 773 pfd[0].fd = data->stream.fd; 774 pfd[0].events = POLLIN; 775 pfd[0].revents = 0; 776 777 return 1; 778} 779 780static int bluetooth_poll_revents(snd_pcm_ioplug_t *io ATTRIBUTE_UNUSED, 781 struct pollfd *pfds, unsigned int nfds, 782 unsigned short *revents) 783{ 784 assert(pfds && nfds == 1 && revents); 785 786 *revents = pfds[0].revents; 787 788 return 0; 789} 790 791static int bluetooth_playback_poll_descriptors_count(snd_pcm_ioplug_t *io) 792{ 793 return 2; 794} 795 796static int bluetooth_playback_poll_descriptors(snd_pcm_ioplug_t *io, 797 struct pollfd *pfd, unsigned int space) 798{ 799 struct bluetooth_data *data = io->private_data; 800 801 DBG(""); 802 803 assert(data->pipefd[0] >= 0); 804 805 if (space < 2) 806 return 0; 807 808 pfd[0].fd = data->pipefd[0]; 809 pfd[0].events = POLLIN; 810 pfd[0].revents = 0; 811 pfd[1].fd = data->stream.fd; 812 pfd[1].events = POLLERR | POLLHUP | POLLNVAL; 813 pfd[1].revents = 0; 814 815 return 2; 816} 817 818static int bluetooth_playback_poll_revents(snd_pcm_ioplug_t *io, 819 struct pollfd *pfds, unsigned int nfds, 820 unsigned short *revents) 821{ 822 static char buf[1]; 823 824 DBG(""); 825 826 assert(pfds); 827 assert(nfds == 2); 828 assert(revents); 829 assert(pfds[0].fd >= 0); 830 assert(pfds[1].fd >= 0); 831 832 if (io->state != SND_PCM_STATE_PREPARED) 833 if (read(pfds[0].fd, buf, 1) < 0) 834 SYSERR("read error: %s (%d)", strerror(errno), errno); 835 836 if (pfds[1].revents & (POLLERR | POLLHUP | POLLNVAL)) 837 io->state = SND_PCM_STATE_DISCONNECTED; 838 839 *revents = (pfds[0].revents & POLLIN) ? POLLOUT : 0; 840 841 return 0; 842} 843 844 845static snd_pcm_sframes_t bluetooth_hsp_read(snd_pcm_ioplug_t *io, 846 const snd_pcm_channel_area_t *areas, 847 snd_pcm_uframes_t offset, 848 snd_pcm_uframes_t size) 849{ 850 struct bluetooth_data *data = io->private_data; 851 snd_pcm_uframes_t frames_to_write, ret; 852 unsigned char *buff; 853 unsigned int frame_size = 0; 854 int nrecv; 855 856 DBG("areas->step=%u areas->first=%u offset=%lu size=%lu io->nonblock=%u", 857 areas->step, areas->first, offset, size, io->nonblock); 858 859 frame_size = areas->step / 8; 860 861 if (data->count > 0) 862 goto proceed; 863 864 nrecv = recv(data->stream.fd, data->buffer, data->link_mtu, 865 io->nonblock ? MSG_DONTWAIT : 0); 866 867 if (nrecv < 0) { 868 ret = (errno == EPIPE) ? -EIO : -errno; 869 goto done; 870 } 871 872 if ((unsigned int) nrecv != data->link_mtu) { 873 ret = -EIO; 874 SNDERR(strerror(-ret)); 875 goto done; 876 } 877 878 /* Increment hardware transmition pointer */ 879 data->hw_ptr = (data->hw_ptr + data->link_mtu / frame_size) % 880 io->buffer_size; 881 882proceed: 883 buff = (unsigned char *) areas->addr + 884 (areas->first + areas->step * offset) / 8; 885 886 if ((data->count + size * frame_size) <= data->link_mtu) 887 frames_to_write = size; 888 else 889 frames_to_write = (data->link_mtu - data->count) / frame_size; 890 891 memcpy(buff, data->buffer + data->count, frame_size * frames_to_write); 892 data->count += (frame_size * frames_to_write); 893 data->count %= data->link_mtu; 894 895 /* Return written frames count */ 896 ret = frames_to_write; 897 898done: 899 DBG("returning %lu", ret); 900 return ret; 901} 902 903static snd_pcm_sframes_t bluetooth_hsp_write(snd_pcm_ioplug_t *io, 904 const snd_pcm_channel_area_t *areas, 905 snd_pcm_uframes_t offset, 906 snd_pcm_uframes_t size) 907{ 908 struct bluetooth_data *data = io->private_data; 909 snd_pcm_sframes_t ret = 0; 910 snd_pcm_uframes_t frames_to_read; 911 uint8_t *buff; 912 int rsend, frame_size; 913 914 DBG("areas->step=%u areas->first=%u offset=%lu, size=%lu io->nonblock=%u", 915 areas->step, areas->first, offset, size, io->nonblock); 916 917 if (io->hw_ptr > io->appl_ptr) { 918 ret = bluetooth_playback_stop(io); 919 if (ret == 0) 920 ret = -EPIPE; 921 goto done; 922 } 923 924 frame_size = areas->step / 8; 925 if ((data->count + size * frame_size) <= data->link_mtu) 926 frames_to_read = size; 927 else 928 frames_to_read = (data->link_mtu - data->count) / frame_size; 929 930 DBG("count=%d frames_to_read=%lu", data->count, frames_to_read); 931 932 /* Ready for more data */ 933 buff = (uint8_t *) areas->addr + 934 (areas->first + areas->step * offset) / 8; 935 memcpy(data->buffer + data->count, buff, frame_size * frames_to_read); 936 937 /* Remember we have some frames in the pipe now */ 938 data->count += frames_to_read * frame_size; 939 if (data->count != data->link_mtu) { 940 ret = frames_to_read; 941 goto done; 942 } 943 944 rsend = send(data->stream.fd, data->buffer, data->link_mtu, 945 io->nonblock ? MSG_DONTWAIT : 0); 946 if (rsend > 0) { 947 /* Reset count pointer */ 948 data->count = 0; 949 950 ret = frames_to_read; 951 } else if (rsend < 0) 952 ret = (errno == EPIPE) ? -EIO : -errno; 953 else 954 ret = -EIO; 955 956done: 957 DBG("returning %ld", ret); 958 return ret; 959} 960 961static snd_pcm_sframes_t bluetooth_a2dp_read(snd_pcm_ioplug_t *io, 962 const snd_pcm_channel_area_t *areas, 963 snd_pcm_uframes_t offset, snd_pcm_uframes_t size) 964{ 965 snd_pcm_uframes_t ret = 0; 966 return ret; 967} 968 969static int avdtp_write(struct bluetooth_data *data) 970{ 971 int ret = 0; 972 struct rtp_header *header; 973 struct rtp_payload *payload; 974 struct bluetooth_a2dp *a2dp = &data->a2dp; 975 976 header = (void *) a2dp->buffer; 977 payload = (void *) (a2dp->buffer + sizeof(*header)); 978 979 memset(a2dp->buffer, 0, sizeof(*header) + sizeof(*payload)); 980 981 payload->frame_count = a2dp->frame_count; 982 header->v = 2; 983 header->pt = 1; 984 header->sequence_number = htons(a2dp->seq_num); 985 header->timestamp = htonl(a2dp->nsamples); 986 header->ssrc = htonl(1); 987 988 ret = send(data->stream.fd, a2dp->buffer, a2dp->count, MSG_DONTWAIT); 989 if (ret < 0) { 990 DBG("send returned %d errno %s.", ret, strerror(errno)); 991 ret = -errno; 992 } 993 994 /* Reset buffer of data to send */ 995 a2dp->count = sizeof(struct rtp_header) + sizeof(struct rtp_payload); 996 a2dp->frame_count = 0; 997 a2dp->samples = 0; 998 a2dp->seq_num++; 999 1000 return ret; 1001} 1002 1003static snd_pcm_sframes_t bluetooth_a2dp_write(snd_pcm_ioplug_t *io, 1004 const snd_pcm_channel_area_t *areas, 1005 snd_pcm_uframes_t offset, snd_pcm_uframes_t size) 1006{ 1007 struct bluetooth_data *data = io->private_data; 1008 struct bluetooth_a2dp *a2dp = &data->a2dp; 1009 snd_pcm_sframes_t ret = 0; 1010 unsigned int bytes_left; 1011 int frame_size, encoded; 1012 ssize_t written; 1013 uint8_t *buff; 1014 1015 DBG("areas->step=%u areas->first=%u offset=%lu size=%lu", 1016 areas->step, areas->first, offset, size); 1017 DBG("hw_ptr=%lu appl_ptr=%lu diff=%lu", io->hw_ptr, io->appl_ptr, 1018 io->appl_ptr - io->hw_ptr); 1019 1020 /* Calutate starting pointers */ 1021 frame_size = areas->step / 8; 1022 bytes_left = size * frame_size; 1023 buff = (uint8_t *) areas->addr + 1024 (areas->first + areas->step * (offset)) / 8; 1025 1026 /* Check for underrun */ 1027 if (io->hw_ptr > io->appl_ptr) { 1028 ret = bluetooth_playback_stop(io); 1029 if (ret == 0) 1030 ret = -EPIPE; 1031 data->reset = 1; 1032 return ret; 1033 } 1034 1035 /* Check if we should autostart */ 1036 if (io->state == SND_PCM_STATE_PREPARED) { 1037 snd_pcm_sw_params_t *swparams; 1038 snd_pcm_uframes_t threshold; 1039 1040 snd_pcm_sw_params_malloc(&swparams); 1041 if (!snd_pcm_sw_params_current(io->pcm, swparams) && 1042 !snd_pcm_sw_params_get_start_threshold(swparams, 1043 &threshold)) { 1044 if (io->appl_ptr >= threshold) { 1045 ret = snd_pcm_start(io->pcm); 1046 if (ret != 0) 1047 return ret; 1048 } 1049 } 1050 1051 snd_pcm_sw_params_free(swparams); 1052 } 1053 1054 /* Check if we have any left over data from the last write */ 1055 if (data->count > 0) { 1056 unsigned int additional_bytes_needed = 1057 a2dp->codesize - data->count; 1058 if (additional_bytes_needed > bytes_left) 1059 goto out; 1060 1061 memcpy(data->buffer + data->count, buff, 1062 additional_bytes_needed); 1063 1064 /* Enough data to encode (sbc wants 1k blocks) */ 1065 encoded = sbc_encode(&a2dp->sbc, data->buffer, a2dp->codesize, 1066 a2dp->buffer + a2dp->count, 1067 sizeof(a2dp->buffer) - a2dp->count, 1068 &written); 1069 if (encoded <= 0) { 1070 DBG("Encoding error %d", encoded); 1071 goto done; 1072 } 1073 1074 /* Increment a2dp buffers */ 1075 a2dp->count += written; 1076 a2dp->frame_count++; 1077 a2dp->samples += encoded / frame_size; 1078 a2dp->nsamples += encoded / frame_size; 1079 1080 /* No space left for another frame then send */ 1081 if (a2dp->count + written >= data->link_mtu) { 1082 avdtp_write(data); 1083 DBG("sending packet %d, count %d, link_mtu %u", 1084 a2dp->seq_num, a2dp->count, 1085 data->link_mtu); 1086 } 1087 1088 /* Increment up buff pointer to take into account 1089 * the data processed */ 1090 buff += additional_bytes_needed; 1091 bytes_left -= additional_bytes_needed; 1092 1093 /* Since data has been process mark it as zero */ 1094 data->count = 0; 1095 } 1096 1097 1098 /* Process this buffer in full chunks */ 1099 while (bytes_left >= a2dp->codesize) { 1100 /* Enough data to encode (sbc wants 1k blocks) */ 1101 encoded = sbc_encode(&a2dp->sbc, buff, a2dp->codesize, 1102 a2dp->buffer + a2dp->count, 1103 sizeof(a2dp->buffer) - a2dp->count, 1104 &written); 1105 if (encoded <= 0) { 1106 DBG("Encoding error %d", encoded); 1107 goto done; 1108 } 1109 1110 /* Increment up buff pointer to take into account 1111 * the data processed */ 1112 buff += a2dp->codesize; 1113 bytes_left -= a2dp->codesize; 1114 1115 /* Increment a2dp buffers */ 1116 a2dp->count += written; 1117 a2dp->frame_count++; 1118 a2dp->samples += encoded / frame_size; 1119 a2dp->nsamples += encoded / frame_size; 1120 1121 /* No space left for another frame then send */ 1122 if (a2dp->count + written >= data->link_mtu) { 1123 avdtp_write(data); 1124 DBG("sending packet %d, count %d, link_mtu %u", 1125 a2dp->seq_num, a2dp->count, 1126 data->link_mtu); 1127 } 1128 } 1129 1130out: 1131 /* Copy the extra to our temp buffer for the next write */ 1132 if (bytes_left > 0) { 1133 memcpy(data->buffer + data->count, buff, bytes_left); 1134 data->count += bytes_left; 1135 bytes_left = 0; 1136 } 1137 1138done: 1139 DBG("returning %ld", size - bytes_left / frame_size); 1140 1141 return size - bytes_left / frame_size; 1142} 1143 1144static int bluetooth_playback_delay(snd_pcm_ioplug_t *io, 1145 snd_pcm_sframes_t *delayp) 1146{ 1147 DBG(""); 1148 1149 /* This updates io->hw_ptr value using pointer() function */ 1150 snd_pcm_hwsync(io->pcm); 1151 1152 *delayp = io->appl_ptr - io->hw_ptr; 1153 if ((io->state == SND_PCM_STATE_RUNNING) && (*delayp < 0)) { 1154 io->callback->stop(io); 1155 io->state = SND_PCM_STATE_XRUN; 1156 *delayp = 0; 1157 } 1158 1159 /* This should never fail, ALSA API is really not 1160 prepared to handle a non zero return value */ 1161 return 0; 1162} 1163 1164static snd_pcm_ioplug_callback_t bluetooth_hsp_playback = { 1165 .start = bluetooth_playback_start, 1166 .stop = bluetooth_playback_stop, 1167 .pointer = bluetooth_pointer, 1168 .close = bluetooth_close, 1169 .hw_params = bluetooth_hsp_hw_params, 1170 .prepare = bluetooth_prepare, 1171 .transfer = bluetooth_hsp_write, 1172 .poll_descriptors_count = bluetooth_playback_poll_descriptors_count, 1173 .poll_descriptors = bluetooth_playback_poll_descriptors, 1174 .poll_revents = bluetooth_playback_poll_revents, 1175 .delay = bluetooth_playback_delay, 1176}; 1177 1178static snd_pcm_ioplug_callback_t bluetooth_hsp_capture = { 1179 .start = bluetooth_start, 1180 .stop = bluetooth_stop, 1181 .pointer = bluetooth_pointer, 1182 .close = bluetooth_close, 1183 .hw_params = bluetooth_hsp_hw_params, 1184 .prepare = bluetooth_prepare, 1185 .transfer = bluetooth_hsp_read, 1186 .poll_descriptors = bluetooth_poll_descriptors, 1187 .poll_revents = bluetooth_poll_revents, 1188}; 1189 1190static snd_pcm_ioplug_callback_t bluetooth_a2dp_playback = { 1191 .start = bluetooth_playback_start, 1192 .stop = bluetooth_playback_stop, 1193 .pointer = bluetooth_pointer, 1194 .close = bluetooth_close, 1195 .hw_params = bluetooth_a2dp_hw_params, 1196 .prepare = bluetooth_prepare, 1197 .transfer = bluetooth_a2dp_write, 1198 .poll_descriptors_count = bluetooth_playback_poll_descriptors_count, 1199 .poll_descriptors = bluetooth_playback_poll_descriptors, 1200 .poll_revents = bluetooth_playback_poll_revents, 1201 .delay = bluetooth_playback_delay, 1202}; 1203 1204static snd_pcm_ioplug_callback_t bluetooth_a2dp_capture = { 1205 .start = bluetooth_start, 1206 .stop = bluetooth_stop, 1207 .pointer = bluetooth_pointer, 1208 .close = bluetooth_close, 1209 .hw_params = bluetooth_a2dp_hw_params, 1210 .prepare = bluetooth_prepare, 1211 .transfer = bluetooth_a2dp_read, 1212 .poll_descriptors = bluetooth_poll_descriptors, 1213 .poll_revents = bluetooth_poll_revents, 1214}; 1215 1216#define ARRAY_NELEMS(a) (sizeof((a)) / sizeof((a)[0])) 1217 1218static int bluetooth_hsp_hw_constraint(snd_pcm_ioplug_t *io) 1219{ 1220 struct bluetooth_data *data = io->private_data; 1221 snd_pcm_access_t access_list[] = { 1222 SND_PCM_ACCESS_RW_INTERLEAVED, 1223 /* Mmap access is really useless fo this driver, but we 1224 * support it because some pieces of software out there 1225 * insist on using it */ 1226 SND_PCM_ACCESS_MMAP_INTERLEAVED 1227 }; 1228 unsigned int format_list[] = { 1229 SND_PCM_FORMAT_S16 1230 }; 1231 int err; 1232 1233 /* access type */ 1234 err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_ACCESS, 1235 ARRAY_NELEMS(access_list), access_list); 1236 if (err < 0) 1237 return err; 1238 1239 /* supported formats */ 1240 err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_FORMAT, 1241 ARRAY_NELEMS(format_list), format_list); 1242 if (err < 0) 1243 return err; 1244 1245 /* supported channels */ 1246 err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_CHANNELS, 1247 1, 1); 1248 if (err < 0) 1249 return err; 1250 1251 /* supported rate */ 1252 err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_RATE, 1253 8000, 8000); 1254 if (err < 0) 1255 return err; 1256 1257 /* supported block size */ 1258 err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_PERIOD_BYTES, 1259 data->link_mtu, data->link_mtu); 1260 if (err < 0) 1261 return err; 1262 1263 err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_PERIODS, 1264 2, 200); 1265 if (err < 0) 1266 return err; 1267 1268 return 0; 1269} 1270 1271static int bluetooth_a2dp_hw_constraint(snd_pcm_ioplug_t *io) 1272{ 1273 struct bluetooth_data *data = io->private_data; 1274 struct bluetooth_a2dp *a2dp = &data->a2dp; 1275 struct bluetooth_alsa_config *cfg = &data->alsa_config; 1276 snd_pcm_access_t access_list[] = { 1277 SND_PCM_ACCESS_RW_INTERLEAVED, 1278 /* Mmap access is really useless fo this driver, but we 1279 * support it because some pieces of software out there 1280 * insist on using it */ 1281 SND_PCM_ACCESS_MMAP_INTERLEAVED 1282 }; 1283 unsigned int format_list[] = { 1284 SND_PCM_FORMAT_S16 1285 }; 1286 unsigned int rate_list[4]; 1287 unsigned int rate_count; 1288 int err, min_channels, max_channels; 1289 unsigned int period_list[] = { 1290 2048, 1291 4096, /* e.g. 23.2msec/period (stereo 16bit at 44.1kHz) */ 1292 8192 1293 }; 1294 1295 /* access type */ 1296 err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_ACCESS, 1297 ARRAY_NELEMS(access_list), access_list); 1298 if (err < 0) 1299 return err; 1300 1301 /* supported formats */ 1302 err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_FORMAT, 1303 ARRAY_NELEMS(format_list), format_list); 1304 if (err < 0) 1305 return err; 1306 1307 /* supported channels */ 1308 if (cfg->has_channel_mode) 1309 a2dp->sbc_capabilities.channel_mode = cfg->channel_mode; 1310 1311 if (a2dp->sbc_capabilities.channel_mode & 1312 BT_A2DP_CHANNEL_MODE_MONO) 1313 min_channels = 1; 1314 else 1315 min_channels = 2; 1316 1317 if (a2dp->sbc_capabilities.channel_mode & 1318 (~BT_A2DP_CHANNEL_MODE_MONO)) 1319 max_channels = 2; 1320 else 1321 max_channels = 1; 1322 1323 err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_CHANNELS, 1324 min_channels, max_channels); 1325 if (err < 0) 1326 return err; 1327 1328 /* supported buffer sizes 1329 * (can be used as 3*8192, 6*4096, 12*2048, ...) */ 1330 err = snd_pcm_ioplug_set_param_minmax(io, 1331 SND_PCM_IOPLUG_HW_BUFFER_BYTES, 1332 8192*3, 8192*3); 1333 if (err < 0) 1334 return err; 1335 1336 /* supported block sizes: */ 1337 err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_PERIOD_BYTES, 1338 ARRAY_NELEMS(period_list), period_list); 1339 if (err < 0) 1340 return err; 1341 1342 /* supported rates */ 1343 rate_count = 0; 1344 if (cfg->has_rate) { 1345 rate_list[rate_count] = cfg->rate; 1346 rate_count++; 1347 } else { 1348 if (a2dp->sbc_capabilities.frequency & 1349 BT_SBC_SAMPLING_FREQ_16000) { 1350 rate_list[rate_count] = 16000; 1351 rate_count++; 1352 } 1353 1354 if (a2dp->sbc_capabilities.frequency & 1355 BT_SBC_SAMPLING_FREQ_32000) { 1356 rate_list[rate_count] = 32000; 1357 rate_count++; 1358 } 1359 1360 if (a2dp->sbc_capabilities.frequency & 1361 BT_SBC_SAMPLING_FREQ_44100) { 1362 rate_list[rate_count] = 44100; 1363 rate_count++; 1364 } 1365 1366 if (a2dp->sbc_capabilities.frequency & 1367 BT_SBC_SAMPLING_FREQ_48000) { 1368 rate_list[rate_count] = 48000; 1369 rate_count++; 1370 } 1371 } 1372 1373 err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_RATE, 1374 rate_count, rate_list); 1375 if (err < 0) 1376 return err; 1377 1378 return 0; 1379} 1380 1381static int bluetooth_parse_config(snd_config_t *conf, 1382 struct bluetooth_alsa_config *bt_config) 1383{ 1384 snd_config_iterator_t i, next; 1385 1386 memset(bt_config, 0, sizeof(struct bluetooth_alsa_config)); 1387 1388 /* Set defaults */ 1389 bt_config->autoconnect = 1; 1390 1391 snd_config_for_each(i, next, conf) { 1392 snd_config_t *n = snd_config_iterator_entry(i); 1393 const char *id, *value; 1394 1395 if (snd_config_get_id(n, &id) < 0) 1396 continue; 1397 1398 if (strcmp(id, "comment") == 0 || strcmp(id, "type") == 0) 1399 continue; 1400 1401 if (strcmp(id, "autoconnect") == 0) { 1402 int b; 1403 1404 b = snd_config_get_bool(n); 1405 if (b < 0) { 1406 SNDERR("Invalid type for %s", id); 1407 return -EINVAL; 1408 } 1409 1410 bt_config->autoconnect = b; 1411 continue; 1412 } 1413 1414 if (strcmp(id, "device") == 0 || strcmp(id, "bdaddr") == 0) { 1415 if (snd_config_get_string(n, &value) < 0) { 1416 SNDERR("Invalid type for %s", id); 1417 return -EINVAL; 1418 } 1419 1420 bt_config->has_device = 1; 1421 strncpy(bt_config->device, value, 18); 1422 continue; 1423 } 1424 1425 if (strcmp(id, "profile") == 0) { 1426 if (snd_config_get_string(n, &value) < 0) { 1427 SNDERR("Invalid type for %s", id); 1428 return -EINVAL; 1429 } 1430 1431 if (strcmp(value, "auto") == 0) { 1432 bt_config->transport = BT_CAPABILITIES_TRANSPORT_ANY; 1433 bt_config->has_transport = 1; 1434 } else if (strcmp(value, "voice") == 0 || 1435 strcmp(value, "hfp") == 0) { 1436 bt_config->transport = BT_CAPABILITIES_TRANSPORT_SCO; 1437 bt_config->has_transport = 1; 1438 } else if (strcmp(value, "hifi") == 0 || 1439 strcmp(value, "a2dp") == 0) { 1440 bt_config->transport = BT_CAPABILITIES_TRANSPORT_A2DP; 1441 bt_config->has_transport = 1; 1442 } 1443 continue; 1444 } 1445 1446 if (strcmp(id, "rate") == 0) { 1447 if (snd_config_get_string(n, &value) < 0) { 1448 SNDERR("Invalid type for %s", id); 1449 return -EINVAL; 1450 } 1451 1452 bt_config->rate = atoi(value); 1453 bt_config->has_rate = 1; 1454 continue; 1455 } 1456 1457 if (strcmp(id, "mode") == 0) { 1458 if (snd_config_get_string(n, &value) < 0) { 1459 SNDERR("Invalid type for %s", id); 1460 return -EINVAL; 1461 } 1462 1463 if (strcmp(value, "mono") == 0) { 1464 bt_config->channel_mode = BT_A2DP_CHANNEL_MODE_MONO; 1465 bt_config->has_channel_mode = 1; 1466 } else if (strcmp(value, "dual") == 0) { 1467 bt_config->channel_mode = BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL; 1468 bt_config->has_channel_mode = 1; 1469 } else if (strcmp(value, "stereo") == 0) { 1470 bt_config->channel_mode = BT_A2DP_CHANNEL_MODE_STEREO; 1471 bt_config->has_channel_mode = 1; 1472 } else if (strcmp(value, "joint") == 0) { 1473 bt_config->channel_mode = BT_A2DP_CHANNEL_MODE_JOINT_STEREO; 1474 bt_config->has_channel_mode = 1; 1475 } 1476 continue; 1477 } 1478 1479 if (strcmp(id, "allocation") == 0) { 1480 if (snd_config_get_string(n, &value) < 0) { 1481 SNDERR("Invalid type for %s", id); 1482 return -EINVAL; 1483 } 1484 1485 if (strcmp(value, "loudness") == 0) { 1486 bt_config->allocation_method = BT_A2DP_ALLOCATION_LOUDNESS; 1487 bt_config->has_allocation_method = 1; 1488 } else if (strcmp(value, "snr") == 0) { 1489 bt_config->allocation_method = BT_A2DP_ALLOCATION_SNR; 1490 bt_config->has_allocation_method = 1; 1491 } 1492 continue; 1493 } 1494 1495 if (strcmp(id, "subbands") == 0) { 1496 if (snd_config_get_string(n, &value) < 0) { 1497 SNDERR("Invalid type for %s", id); 1498 return -EINVAL; 1499 } 1500 1501 bt_config->subbands = atoi(value); 1502 bt_config->has_subbands = 1; 1503 continue; 1504 } 1505 1506 if (strcmp(id, "blocks") == 0) { 1507 if (snd_config_get_string(n, &value) < 0) { 1508 SNDERR("Invalid type for %s", id); 1509 return -EINVAL; 1510 } 1511 1512 bt_config->block_length = atoi(value); 1513 bt_config->has_block_length = 1; 1514 continue; 1515 } 1516 1517 if (strcmp(id, "bitpool") == 0) { 1518 if (snd_config_get_string(n, &value) < 0) { 1519 SNDERR("Invalid type for %s", id); 1520 return -EINVAL; 1521 } 1522 1523 bt_config->bitpool = atoi(value); 1524 bt_config->has_bitpool = 1; 1525 continue; 1526 } 1527 1528 SNDERR("Unknown field %s", id); 1529 return -EINVAL; 1530 } 1531 1532 return 0; 1533} 1534 1535static int audioservice_send(int sk, const bt_audio_msg_header_t *msg) 1536{ 1537 int err; 1538 uint16_t length; 1539 1540 length = msg->length ? msg->length : BT_SUGGESTED_BUFFER_SIZE; 1541 1542 DBG("sending %s:%s", bt_audio_strtype(msg->type), 1543 bt_audio_strname(msg->name)); 1544 if (send(sk, msg, length, 0) > 0) 1545 err = 0; 1546 else { 1547 err = -errno; 1548 SNDERR("Error sending data to audio service: %s(%d)", 1549 strerror(errno), errno); 1550 } 1551 1552 return err; 1553} 1554 1555static int audioservice_recv(int sk, bt_audio_msg_header_t *inmsg) 1556{ 1557 int err; 1558 ssize_t ret; 1559 const char *type, *name; 1560 uint16_t length; 1561 1562 length = inmsg->length ? inmsg->length : BT_SUGGESTED_BUFFER_SIZE; 1563 1564 DBG("trying to receive msg from audio service..."); 1565 1566 ret = recv(sk, inmsg, length, 0); 1567 if (ret < 0) { 1568 err = -errno; 1569 SNDERR("Error receiving IPC data from bluetoothd: %s (%d)", 1570 strerror(errno), errno); 1571 } else if ((size_t) ret < sizeof(bt_audio_msg_header_t)) { 1572 SNDERR("Too short (%d bytes) IPC packet from bluetoothd", ret); 1573 err = -EINVAL; 1574 } else { 1575 type = bt_audio_strtype(inmsg->type); 1576 name = bt_audio_strname(inmsg->name); 1577 if (type && name) { 1578 DBG("Received %s - %s", type, name); 1579 err = 0; 1580 } else { 1581 err = -EINVAL; 1582 SNDERR("Bogus message type %d - name %d" 1583 " received from audio service", 1584 inmsg->type, inmsg->name); 1585 } 1586 1587 } 1588 1589 return err; 1590} 1591 1592static int audioservice_expect(int sk, bt_audio_msg_header_t *rsp, 1593 int expected_name) 1594{ 1595 bt_audio_error_t *error; 1596 int err = audioservice_recv(sk, rsp); 1597 1598 if (err != 0) 1599 return err; 1600 1601 if (rsp->name != expected_name) { 1602 err = -EINVAL; 1603 SNDERR("Bogus message %s received while %s was expected", 1604 bt_audio_strname(rsp->name), 1605 bt_audio_strname(expected_name)); 1606 } 1607 1608 if (rsp->type == BT_ERROR) { 1609 error = (void *) rsp; 1610 SNDERR("%s failed : %s(%d)", 1611 bt_audio_strname(rsp->name), 1612 strerror(error->posix_errno), 1613 error->posix_errno); 1614 return -error->posix_errno; 1615 } 1616 1617 return err; 1618} 1619 1620static int bluetooth_parse_capabilities(struct bluetooth_data *data, 1621 struct bt_get_capabilities_rsp *rsp) 1622{ 1623 int bytes_left = rsp->h.length - sizeof(*rsp); 1624 codec_capabilities_t *codec = (void *) rsp->data; 1625 1626 data->transport = codec->transport; 1627 1628 if (codec->transport != BT_CAPABILITIES_TRANSPORT_A2DP) 1629 return 0; 1630 1631 while (bytes_left > 0) { 1632 if ((codec->type == BT_A2DP_SBC_SINK) && 1633 !(codec->lock & BT_WRITE_LOCK)) 1634 break; 1635 1636 bytes_left -= codec->length; 1637 codec = (void *) codec + codec->length; 1638 } 1639 1640 if (bytes_left <= 0 || 1641 codec->length != sizeof(data->a2dp.sbc_capabilities)) 1642 return -EINVAL; 1643 1644 memcpy(&data->a2dp.sbc_capabilities, codec, codec->length); 1645 1646 return 0; 1647} 1648 1649static int bluetooth_init(struct bluetooth_data *data, 1650 snd_pcm_stream_t stream, snd_config_t *conf) 1651{ 1652 int sk, err; 1653 struct bluetooth_alsa_config *alsa_conf = &data->alsa_config; 1654 char buf[BT_SUGGESTED_BUFFER_SIZE]; 1655 struct bt_get_capabilities_req *req = (void *) buf; 1656 struct bt_get_capabilities_rsp *rsp = (void *) buf; 1657 1658 memset(data, 0, sizeof(struct bluetooth_data)); 1659 1660 err = bluetooth_parse_config(conf, alsa_conf); 1661 if (err < 0) 1662 return err; 1663 1664 data->server.fd = -1; 1665 data->stream.fd = -1; 1666 1667 sk = bt_audio_service_open(); 1668 if (sk <= 0) { 1669 err = -errno; 1670 goto failed; 1671 } 1672 1673 data->server.fd = sk; 1674 data->server.events = POLLIN; 1675 1676 data->pipefd[0] = -1; 1677 data->pipefd[1] = -1; 1678 1679 if (pipe(data->pipefd) < 0) { 1680 err = -errno; 1681 goto failed; 1682 } 1683 if (fcntl(data->pipefd[0], F_SETFL, O_NONBLOCK) < 0) { 1684 err = -errno; 1685 goto failed; 1686 } 1687 if (fcntl(data->pipefd[1], F_SETFL, O_NONBLOCK) < 0) { 1688 err = -errno; 1689 goto failed; 1690 } 1691 1692 memset(req, 0, BT_SUGGESTED_BUFFER_SIZE); 1693 req->h.type = BT_REQUEST; 1694 req->h.name = BT_GET_CAPABILITIES; 1695 req->h.length = sizeof(*req); 1696 1697 if (alsa_conf->autoconnect) 1698 req->flags |= BT_FLAG_AUTOCONNECT; 1699 strncpy(req->destination, alsa_conf->device, 18); 1700 if (alsa_conf->has_transport) 1701 req->transport = alsa_conf->transport; 1702 else 1703 req->transport = BT_CAPABILITIES_TRANSPORT_ANY; 1704 1705 err = audioservice_send(data->server.fd, &req->h); 1706 if (err < 0) 1707 goto failed; 1708 1709 rsp->h.length = 0; 1710 err = audioservice_expect(data->server.fd, &rsp->h, 1711 BT_GET_CAPABILITIES); 1712 if (err < 0) 1713 goto failed; 1714 1715 bluetooth_parse_capabilities(data, rsp); 1716 1717 return 0; 1718 1719failed: 1720 if (sk >= 0) 1721 bt_audio_service_close(sk); 1722 return err; 1723} 1724 1725SND_PCM_PLUGIN_DEFINE_FUNC(bluetooth); 1726 1727SND_PCM_PLUGIN_DEFINE_FUNC(bluetooth) 1728{ 1729 struct bluetooth_data *data; 1730 int err; 1731 1732 DBG("Bluetooth PCM plugin (%s)", 1733 stream == SND_PCM_STREAM_PLAYBACK ? "Playback" : "Capture"); 1734 1735 data = malloc(sizeof(struct bluetooth_data)); 1736 if (!data) { 1737 err = -ENOMEM; 1738 goto error; 1739 } 1740 1741 err = bluetooth_init(data, stream, conf); 1742 if (err < 0) 1743 goto error; 1744 1745 data->io.version = SND_PCM_IOPLUG_VERSION; 1746 data->io.name = "Bluetooth Audio Device"; 1747 data->io.mmap_rw = 0; /* No direct mmap communication */ 1748 data->io.private_data = data; 1749 1750 if (data->transport == BT_CAPABILITIES_TRANSPORT_A2DP) 1751 data->io.callback = stream == SND_PCM_STREAM_PLAYBACK ? 1752 &bluetooth_a2dp_playback : 1753 &bluetooth_a2dp_capture; 1754 else 1755 data->io.callback = stream == SND_PCM_STREAM_PLAYBACK ? 1756 &bluetooth_hsp_playback : 1757 &bluetooth_hsp_capture; 1758 1759 err = snd_pcm_ioplug_create(&data->io, name, stream, mode); 1760 if (err < 0) 1761 goto error; 1762 1763 if (data->transport == BT_CAPABILITIES_TRANSPORT_A2DP) 1764 err = bluetooth_a2dp_hw_constraint(&data->io); 1765 else 1766 err = bluetooth_hsp_hw_constraint(&data->io); 1767 1768 if (err < 0) { 1769 snd_pcm_ioplug_delete(&data->io); 1770 goto error; 1771 } 1772 1773 *pcmp = data->io.pcm; 1774 1775 return 0; 1776 1777error: 1778 if (data) 1779 bluetooth_exit(data); 1780 1781 return err; 1782} 1783 1784SND_PCM_PLUGIN_SYMBOL(bluetooth); 1785