1 /* 2 * compress_core.c - compress offload core 3 * 4 * Copyright (C) 2011 Intel Corporation 5 * Authors: Vinod Koul <vinod.koul@linux.intel.com> 6 * Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com> 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; version 2 of the License. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License along 19 * with this program; if not, write to the Free Software Foundation, Inc., 20 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 21 * 22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 23 * 24 */ 25 #define FORMAT(fmt) "%s: %d: " fmt, __func__, __LINE__ 26 #define pr_fmt(fmt) KBUILD_MODNAME ": " FORMAT(fmt) 27 28 #include <linux/file.h> 29 #include <linux/fs.h> 30 #include <linux/list.h> 31 #include <linux/math64.h> 32 #include <linux/mm.h> 33 #include <linux/mutex.h> 34 #include <linux/poll.h> 35 #include <linux/slab.h> 36 #include <linux/sched.h> 37 #include <linux/types.h> 38 #include <linux/uio.h> 39 #include <linux/uaccess.h> 40 #include <linux/module.h> 41 #include <linux/compat.h> 42 #include <sound/core.h> 43 #include <sound/initval.h> 44 #include <sound/info.h> 45 #include <sound/compress_params.h> 46 #include <sound/compress_offload.h> 47 #include <sound/compress_driver.h> 48 49 /* struct snd_compr_codec_caps overflows the ioctl bit size for some 50 * architectures, so we need to disable the relevant ioctls. 51 */ 52 #if _IOC_SIZEBITS < 14 53 #define COMPR_CODEC_CAPS_OVERFLOW 54 #endif 55 56 /* TODO: 57 * - add substream support for multiple devices in case of 58 * SND_DYNAMIC_MINORS is not used 59 * - Multiple node representation 60 * driver should be able to register multiple nodes 61 */ 62 63 static DEFINE_MUTEX(device_mutex); 64 65 struct snd_compr_file { 66 unsigned long caps; 67 struct snd_compr_stream stream; 68 }; 69 70 /* 71 * a note on stream states used: 72 * we use follwing states in the compressed core 73 * SNDRV_PCM_STATE_OPEN: When stream has been opened. 74 * SNDRV_PCM_STATE_SETUP: When stream has been initialized. This is done by 75 * calling SNDRV_COMPRESS_SET_PARAMS. running streams will come to this 76 * state at stop by calling SNDRV_COMPRESS_STOP, or at end of drain. 77 * SNDRV_PCM_STATE_RUNNING: When stream has been started and is 78 * decoding/encoding and rendering/capturing data. 79 * SNDRV_PCM_STATE_DRAINING: When stream is draining current data. This is done 80 * by calling SNDRV_COMPRESS_DRAIN. 81 * SNDRV_PCM_STATE_PAUSED: When stream is paused. This is done by calling 82 * SNDRV_COMPRESS_PAUSE. It can be stopped or resumed by calling 83 * SNDRV_COMPRESS_STOP or SNDRV_COMPRESS_RESUME respectively. 84 */ 85 static int snd_compr_open(struct inode *inode, struct file *f) 86 { 87 struct snd_compr *compr; 88 struct snd_compr_file *data; 89 struct snd_compr_runtime *runtime; 90 enum snd_compr_direction dirn; 91 int maj = imajor(inode); 92 int ret; 93 94 if ((f->f_flags & O_ACCMODE) == O_WRONLY) 95 dirn = SND_COMPRESS_PLAYBACK; 96 else if ((f->f_flags & O_ACCMODE) == O_RDONLY) 97 dirn = SND_COMPRESS_CAPTURE; 98 else 99 return -EINVAL; 100 101 if (maj == snd_major) 102 compr = snd_lookup_minor_data(iminor(inode), 103 SNDRV_DEVICE_TYPE_COMPRESS); 104 else 105 return -EBADFD; 106 107 if (compr == NULL) { 108 pr_err("no device data!!!\n"); 109 return -ENODEV; 110 } 111 112 if (dirn != compr->direction) { 113 pr_err("this device doesn't support this direction\n"); 114 snd_card_unref(compr->card); 115 return -EINVAL; 116 } 117 118 data = kzalloc(sizeof(*data), GFP_KERNEL); 119 if (!data) { 120 snd_card_unref(compr->card); 121 return -ENOMEM; 122 } 123 data->stream.ops = compr->ops; 124 data->stream.direction = dirn; 125 data->stream.private_data = compr->private_data; 126 data->stream.device = compr; 127 runtime = kzalloc(sizeof(*runtime), GFP_KERNEL); 128 if (!runtime) { 129 kfree(data); 130 snd_card_unref(compr->card); 131 return -ENOMEM; 132 } 133 runtime->state = SNDRV_PCM_STATE_OPEN; 134 init_waitqueue_head(&runtime->sleep); 135 data->stream.runtime = runtime; 136 f->private_data = (void *)data; 137 mutex_lock(&compr->lock); 138 ret = compr->ops->open(&data->stream); 139 mutex_unlock(&compr->lock); 140 if (ret) { 141 kfree(runtime); 142 kfree(data); 143 } 144 snd_card_unref(compr->card); 145 return ret; 146 } 147 148 static int snd_compr_free(struct inode *inode, struct file *f) 149 { 150 struct snd_compr_file *data = f->private_data; 151 struct snd_compr_runtime *runtime = data->stream.runtime; 152 153 switch (runtime->state) { 154 case SNDRV_PCM_STATE_RUNNING: 155 case SNDRV_PCM_STATE_DRAINING: 156 case SNDRV_PCM_STATE_PAUSED: 157 data->stream.ops->trigger(&data->stream, SNDRV_PCM_TRIGGER_STOP); 158 break; 159 default: 160 break; 161 } 162 163 data->stream.ops->free(&data->stream); 164 kfree(data->stream.runtime->buffer); 165 kfree(data->stream.runtime); 166 kfree(data); 167 return 0; 168 } 169 170 static int snd_compr_update_tstamp(struct snd_compr_stream *stream, 171 struct snd_compr_tstamp *tstamp) 172 { 173 if (!stream->ops->pointer) 174 return -ENOTSUPP; 175 stream->ops->pointer(stream, tstamp); 176 pr_debug("dsp consumed till %d total %d bytes\n", 177 tstamp->byte_offset, tstamp->copied_total); 178 if (stream->direction == SND_COMPRESS_PLAYBACK) 179 stream->runtime->total_bytes_transferred = tstamp->copied_total; 180 else 181 stream->runtime->total_bytes_available = tstamp->copied_total; 182 return 0; 183 } 184 185 static size_t snd_compr_calc_avail(struct snd_compr_stream *stream, 186 struct snd_compr_avail *avail) 187 { 188 memset(avail, 0, sizeof(*avail)); 189 snd_compr_update_tstamp(stream, &avail->tstamp); 190 /* Still need to return avail even if tstamp can't be filled in */ 191 192 if (stream->runtime->total_bytes_available == 0 && 193 stream->runtime->state == SNDRV_PCM_STATE_SETUP && 194 stream->direction == SND_COMPRESS_PLAYBACK) { 195 pr_debug("detected init and someone forgot to do a write\n"); 196 return stream->runtime->buffer_size; 197 } 198 pr_debug("app wrote %lld, DSP consumed %lld\n", 199 stream->runtime->total_bytes_available, 200 stream->runtime->total_bytes_transferred); 201 if (stream->runtime->total_bytes_available == 202 stream->runtime->total_bytes_transferred) { 203 if (stream->direction == SND_COMPRESS_PLAYBACK) { 204 pr_debug("both pointers are same, returning full avail\n"); 205 return stream->runtime->buffer_size; 206 } else { 207 pr_debug("both pointers are same, returning no avail\n"); 208 return 0; 209 } 210 } 211 212 avail->avail = stream->runtime->total_bytes_available - 213 stream->runtime->total_bytes_transferred; 214 if (stream->direction == SND_COMPRESS_PLAYBACK) 215 avail->avail = stream->runtime->buffer_size - avail->avail; 216 217 pr_debug("ret avail as %lld\n", avail->avail); 218 return avail->avail; 219 } 220 221 static inline size_t snd_compr_get_avail(struct snd_compr_stream *stream) 222 { 223 struct snd_compr_avail avail; 224 225 return snd_compr_calc_avail(stream, &avail); 226 } 227 228 static int 229 snd_compr_ioctl_avail(struct snd_compr_stream *stream, unsigned long arg) 230 { 231 struct snd_compr_avail ioctl_avail; 232 size_t avail; 233 234 avail = snd_compr_calc_avail(stream, &ioctl_avail); 235 ioctl_avail.avail = avail; 236 237 if (copy_to_user((__u64 __user *)arg, 238 &ioctl_avail, sizeof(ioctl_avail))) 239 return -EFAULT; 240 return 0; 241 } 242 243 static int snd_compr_write_data(struct snd_compr_stream *stream, 244 const char __user *buf, size_t count) 245 { 246 void *dstn; 247 size_t copy; 248 struct snd_compr_runtime *runtime = stream->runtime; 249 /* 64-bit Modulus */ 250 u64 app_pointer = div64_u64(runtime->total_bytes_available, 251 runtime->buffer_size); 252 app_pointer = runtime->total_bytes_available - 253 (app_pointer * runtime->buffer_size); 254 255 dstn = runtime->buffer + app_pointer; 256 pr_debug("copying %ld at %lld\n", 257 (unsigned long)count, app_pointer); 258 if (count < runtime->buffer_size - app_pointer) { 259 if (copy_from_user(dstn, buf, count)) 260 return -EFAULT; 261 } else { 262 copy = runtime->buffer_size - app_pointer; 263 if (copy_from_user(dstn, buf, copy)) 264 return -EFAULT; 265 if (copy_from_user(runtime->buffer, buf + copy, count - copy)) 266 return -EFAULT; 267 } 268 /* if DSP cares, let it know data has been written */ 269 if (stream->ops->ack) 270 stream->ops->ack(stream, count); 271 return count; 272 } 273 274 static ssize_t snd_compr_write(struct file *f, const char __user *buf, 275 size_t count, loff_t *offset) 276 { 277 struct snd_compr_file *data = f->private_data; 278 struct snd_compr_stream *stream; 279 size_t avail; 280 int retval; 281 282 if (snd_BUG_ON(!data)) 283 return -EFAULT; 284 285 stream = &data->stream; 286 mutex_lock(&stream->device->lock); 287 /* write is allowed when stream is running or has been steup */ 288 if (stream->runtime->state != SNDRV_PCM_STATE_SETUP && 289 stream->runtime->state != SNDRV_PCM_STATE_RUNNING) { 290 mutex_unlock(&stream->device->lock); 291 return -EBADFD; 292 } 293 294 avail = snd_compr_get_avail(stream); 295 pr_debug("avail returned %ld\n", (unsigned long)avail); 296 /* calculate how much we can write to buffer */ 297 if (avail > count) 298 avail = count; 299 300 if (stream->ops->copy) { 301 char __user* cbuf = (char __user*)buf; 302 retval = stream->ops->copy(stream, cbuf, avail); 303 } else { 304 retval = snd_compr_write_data(stream, buf, avail); 305 } 306 if (retval > 0) 307 stream->runtime->total_bytes_available += retval; 308 309 /* while initiating the stream, write should be called before START 310 * call, so in setup move state */ 311 if (stream->runtime->state == SNDRV_PCM_STATE_SETUP) { 312 stream->runtime->state = SNDRV_PCM_STATE_PREPARED; 313 pr_debug("stream prepared, Houston we are good to go\n"); 314 } 315 316 mutex_unlock(&stream->device->lock); 317 return retval; 318 } 319 320 321 static ssize_t snd_compr_read(struct file *f, char __user *buf, 322 size_t count, loff_t *offset) 323 { 324 struct snd_compr_file *data = f->private_data; 325 struct snd_compr_stream *stream; 326 size_t avail; 327 int retval; 328 329 if (snd_BUG_ON(!data)) 330 return -EFAULT; 331 332 stream = &data->stream; 333 mutex_lock(&stream->device->lock); 334 335 /* read is allowed when stream is running, paused, draining and setup 336 * (yes setup is state which we transition to after stop, so if user 337 * wants to read data after stop we allow that) 338 */ 339 switch (stream->runtime->state) { 340 case SNDRV_PCM_STATE_OPEN: 341 case SNDRV_PCM_STATE_PREPARED: 342 case SNDRV_PCM_STATE_XRUN: 343 case SNDRV_PCM_STATE_SUSPENDED: 344 case SNDRV_PCM_STATE_DISCONNECTED: 345 retval = -EBADFD; 346 goto out; 347 } 348 349 avail = snd_compr_get_avail(stream); 350 pr_debug("avail returned %ld\n", (unsigned long)avail); 351 /* calculate how much we can read from buffer */ 352 if (avail > count) 353 avail = count; 354 355 if (stream->ops->copy) { 356 retval = stream->ops->copy(stream, buf, avail); 357 } else { 358 retval = -ENXIO; 359 goto out; 360 } 361 if (retval > 0) 362 stream->runtime->total_bytes_transferred += retval; 363 364 out: 365 mutex_unlock(&stream->device->lock); 366 return retval; 367 } 368 369 static int snd_compr_mmap(struct file *f, struct vm_area_struct *vma) 370 { 371 return -ENXIO; 372 } 373 374 static inline int snd_compr_get_poll(struct snd_compr_stream *stream) 375 { 376 if (stream->direction == SND_COMPRESS_PLAYBACK) 377 return POLLOUT | POLLWRNORM; 378 else 379 return POLLIN | POLLRDNORM; 380 } 381 382 static unsigned int snd_compr_poll(struct file *f, poll_table *wait) 383 { 384 struct snd_compr_file *data = f->private_data; 385 struct snd_compr_stream *stream; 386 size_t avail; 387 int retval = 0; 388 389 if (snd_BUG_ON(!data)) 390 return -EFAULT; 391 stream = &data->stream; 392 if (snd_BUG_ON(!stream)) 393 return -EFAULT; 394 395 mutex_lock(&stream->device->lock); 396 if (stream->runtime->state == SNDRV_PCM_STATE_OPEN) { 397 retval = -EBADFD; 398 goto out; 399 } 400 poll_wait(f, &stream->runtime->sleep, wait); 401 402 avail = snd_compr_get_avail(stream); 403 pr_debug("avail is %ld\n", (unsigned long)avail); 404 /* check if we have at least one fragment to fill */ 405 switch (stream->runtime->state) { 406 case SNDRV_PCM_STATE_DRAINING: 407 /* stream has been woken up after drain is complete 408 * draining done so set stream state to stopped 409 */ 410 retval = snd_compr_get_poll(stream); 411 stream->runtime->state = SNDRV_PCM_STATE_SETUP; 412 break; 413 case SNDRV_PCM_STATE_RUNNING: 414 case SNDRV_PCM_STATE_PREPARED: 415 case SNDRV_PCM_STATE_PAUSED: 416 if (avail >= stream->runtime->fragment_size) 417 retval = snd_compr_get_poll(stream); 418 break; 419 default: 420 if (stream->direction == SND_COMPRESS_PLAYBACK) 421 retval = POLLOUT | POLLWRNORM | POLLERR; 422 else 423 retval = POLLIN | POLLRDNORM | POLLERR; 424 break; 425 } 426 out: 427 mutex_unlock(&stream->device->lock); 428 return retval; 429 } 430 431 static int 432 snd_compr_get_caps(struct snd_compr_stream *stream, unsigned long arg) 433 { 434 int retval; 435 struct snd_compr_caps caps; 436 437 if (!stream->ops->get_caps) 438 return -ENXIO; 439 440 memset(&caps, 0, sizeof(caps)); 441 retval = stream->ops->get_caps(stream, &caps); 442 if (retval) 443 goto out; 444 if (copy_to_user((void __user *)arg, &caps, sizeof(caps))) 445 retval = -EFAULT; 446 out: 447 return retval; 448 } 449 450 #ifndef COMPR_CODEC_CAPS_OVERFLOW 451 static int 452 snd_compr_get_codec_caps(struct snd_compr_stream *stream, unsigned long arg) 453 { 454 int retval; 455 struct snd_compr_codec_caps *caps; 456 457 if (!stream->ops->get_codec_caps) 458 return -ENXIO; 459 460 caps = kzalloc(sizeof(*caps), GFP_KERNEL); 461 if (!caps) 462 return -ENOMEM; 463 464 retval = stream->ops->get_codec_caps(stream, caps); 465 if (retval) 466 goto out; 467 if (copy_to_user((void __user *)arg, caps, sizeof(*caps))) 468 retval = -EFAULT; 469 470 out: 471 kfree(caps); 472 return retval; 473 } 474 #endif /* !COMPR_CODEC_CAPS_OVERFLOW */ 475 476 /* revisit this with snd_pcm_preallocate_xxx */ 477 static int snd_compr_allocate_buffer(struct snd_compr_stream *stream, 478 struct snd_compr_params *params) 479 { 480 unsigned int buffer_size; 481 void *buffer; 482 483 buffer_size = params->buffer.fragment_size * params->buffer.fragments; 484 if (stream->ops->copy) { 485 buffer = NULL; 486 /* if copy is defined the driver will be required to copy 487 * the data from core 488 */ 489 } else { 490 buffer = kmalloc(buffer_size, GFP_KERNEL); 491 if (!buffer) 492 return -ENOMEM; 493 } 494 stream->runtime->fragment_size = params->buffer.fragment_size; 495 stream->runtime->fragments = params->buffer.fragments; 496 stream->runtime->buffer = buffer; 497 stream->runtime->buffer_size = buffer_size; 498 return 0; 499 } 500 501 static int snd_compress_check_input(struct snd_compr_params *params) 502 { 503 /* first let's check the buffer parameter's */ 504 if (params->buffer.fragment_size == 0 || 505 params->buffer.fragments > INT_MAX / params->buffer.fragment_size) 506 return -EINVAL; 507 508 /* now codec parameters */ 509 if (params->codec.id == 0 || params->codec.id > SND_AUDIOCODEC_MAX) 510 return -EINVAL; 511 512 if (params->codec.ch_in == 0 || params->codec.ch_out == 0) 513 return -EINVAL; 514 515 return 0; 516 } 517 518 static int 519 snd_compr_set_params(struct snd_compr_stream *stream, unsigned long arg) 520 { 521 struct snd_compr_params *params; 522 int retval; 523 524 if (stream->runtime->state == SNDRV_PCM_STATE_OPEN) { 525 /* 526 * we should allow parameter change only when stream has been 527 * opened not in other cases 528 */ 529 params = kmalloc(sizeof(*params), GFP_KERNEL); 530 if (!params) 531 return -ENOMEM; 532 if (copy_from_user(params, (void __user *)arg, sizeof(*params))) { 533 retval = -EFAULT; 534 goto out; 535 } 536 537 retval = snd_compress_check_input(params); 538 if (retval) 539 goto out; 540 541 retval = snd_compr_allocate_buffer(stream, params); 542 if (retval) { 543 retval = -ENOMEM; 544 goto out; 545 } 546 547 retval = stream->ops->set_params(stream, params); 548 if (retval) 549 goto out; 550 551 stream->metadata_set = false; 552 stream->next_track = false; 553 554 if (stream->direction == SND_COMPRESS_PLAYBACK) 555 stream->runtime->state = SNDRV_PCM_STATE_SETUP; 556 else 557 stream->runtime->state = SNDRV_PCM_STATE_PREPARED; 558 } else { 559 return -EPERM; 560 } 561 out: 562 kfree(params); 563 return retval; 564 } 565 566 static int 567 snd_compr_get_params(struct snd_compr_stream *stream, unsigned long arg) 568 { 569 struct snd_codec *params; 570 int retval; 571 572 if (!stream->ops->get_params) 573 return -EBADFD; 574 575 params = kzalloc(sizeof(*params), GFP_KERNEL); 576 if (!params) 577 return -ENOMEM; 578 retval = stream->ops->get_params(stream, params); 579 if (retval) 580 goto out; 581 if (copy_to_user((char __user *)arg, params, sizeof(*params))) 582 retval = -EFAULT; 583 584 out: 585 kfree(params); 586 return retval; 587 } 588 589 static int 590 snd_compr_get_metadata(struct snd_compr_stream *stream, unsigned long arg) 591 { 592 struct snd_compr_metadata metadata; 593 int retval; 594 595 if (!stream->ops->get_metadata) 596 return -ENXIO; 597 598 if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata))) 599 return -EFAULT; 600 601 retval = stream->ops->get_metadata(stream, &metadata); 602 if (retval != 0) 603 return retval; 604 605 if (copy_to_user((void __user *)arg, &metadata, sizeof(metadata))) 606 return -EFAULT; 607 608 return 0; 609 } 610 611 static int 612 snd_compr_set_metadata(struct snd_compr_stream *stream, unsigned long arg) 613 { 614 struct snd_compr_metadata metadata; 615 int retval; 616 617 if (!stream->ops->set_metadata) 618 return -ENXIO; 619 /* 620 * we should allow parameter change only when stream has been 621 * opened not in other cases 622 */ 623 if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata))) 624 return -EFAULT; 625 626 retval = stream->ops->set_metadata(stream, &metadata); 627 stream->metadata_set = true; 628 629 return retval; 630 } 631 632 static inline int 633 snd_compr_tstamp(struct snd_compr_stream *stream, unsigned long arg) 634 { 635 struct snd_compr_tstamp tstamp = {0}; 636 int ret; 637 638 ret = snd_compr_update_tstamp(stream, &tstamp); 639 if (ret == 0) 640 ret = copy_to_user((struct snd_compr_tstamp __user *)arg, 641 &tstamp, sizeof(tstamp)) ? -EFAULT : 0; 642 return ret; 643 } 644 645 static int snd_compr_pause(struct snd_compr_stream *stream) 646 { 647 int retval; 648 649 if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING) 650 return -EPERM; 651 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_PUSH); 652 if (!retval) 653 stream->runtime->state = SNDRV_PCM_STATE_PAUSED; 654 return retval; 655 } 656 657 static int snd_compr_resume(struct snd_compr_stream *stream) 658 { 659 int retval; 660 661 if (stream->runtime->state != SNDRV_PCM_STATE_PAUSED) 662 return -EPERM; 663 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_RELEASE); 664 if (!retval) 665 stream->runtime->state = SNDRV_PCM_STATE_RUNNING; 666 return retval; 667 } 668 669 static int snd_compr_start(struct snd_compr_stream *stream) 670 { 671 int retval; 672 673 if (stream->runtime->state != SNDRV_PCM_STATE_PREPARED) 674 return -EPERM; 675 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_START); 676 if (!retval) 677 stream->runtime->state = SNDRV_PCM_STATE_RUNNING; 678 return retval; 679 } 680 681 static int snd_compr_stop(struct snd_compr_stream *stream) 682 { 683 int retval; 684 685 if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED || 686 stream->runtime->state == SNDRV_PCM_STATE_SETUP) 687 return -EPERM; 688 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_STOP); 689 if (!retval) { 690 snd_compr_drain_notify(stream); 691 stream->runtime->total_bytes_available = 0; 692 stream->runtime->total_bytes_transferred = 0; 693 } 694 return retval; 695 } 696 697 static int snd_compress_wait_for_drain(struct snd_compr_stream *stream) 698 { 699 int ret; 700 701 /* 702 * We are called with lock held. So drop the lock while we wait for 703 * drain complete notfication from the driver 704 * 705 * It is expected that driver will notify the drain completion and then 706 * stream will be moved to SETUP state, even if draining resulted in an 707 * error. We can trigger next track after this. 708 */ 709 stream->runtime->state = SNDRV_PCM_STATE_DRAINING; 710 mutex_unlock(&stream->device->lock); 711 712 /* we wait for drain to complete here, drain can return when 713 * interruption occurred, wait returned error or success. 714 * For the first two cases we don't do anything different here and 715 * return after waking up 716 */ 717 718 ret = wait_event_interruptible(stream->runtime->sleep, 719 (stream->runtime->state != SNDRV_PCM_STATE_DRAINING)); 720 if (ret == -ERESTARTSYS) 721 pr_debug("wait aborted by a signal"); 722 else if (ret) 723 pr_debug("wait for drain failed with %d\n", ret); 724 725 726 wake_up(&stream->runtime->sleep); 727 mutex_lock(&stream->device->lock); 728 729 return ret; 730 } 731 732 static int snd_compr_drain(struct snd_compr_stream *stream) 733 { 734 int retval; 735 736 if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED || 737 stream->runtime->state == SNDRV_PCM_STATE_SETUP) 738 return -EPERM; 739 740 retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_DRAIN); 741 if (retval) { 742 pr_debug("SND_COMPR_TRIGGER_DRAIN failed %d\n", retval); 743 wake_up(&stream->runtime->sleep); 744 return retval; 745 } 746 747 return snd_compress_wait_for_drain(stream); 748 } 749 750 static int snd_compr_next_track(struct snd_compr_stream *stream) 751 { 752 int retval; 753 754 /* only a running stream can transition to next track */ 755 if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING) 756 return -EPERM; 757 758 /* you can signal next track isf this is intended to be a gapless stream 759 * and current track metadata is set 760 */ 761 if (stream->metadata_set == false) 762 return -EPERM; 763 764 retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_NEXT_TRACK); 765 if (retval != 0) 766 return retval; 767 stream->metadata_set = false; 768 stream->next_track = true; 769 return 0; 770 } 771 772 static int snd_compr_partial_drain(struct snd_compr_stream *stream) 773 { 774 int retval; 775 if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED || 776 stream->runtime->state == SNDRV_PCM_STATE_SETUP) 777 return -EPERM; 778 /* stream can be drained only when next track has been signalled */ 779 if (stream->next_track == false) 780 return -EPERM; 781 782 retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_PARTIAL_DRAIN); 783 if (retval) { 784 pr_debug("Partial drain returned failure\n"); 785 wake_up(&stream->runtime->sleep); 786 return retval; 787 } 788 789 stream->next_track = false; 790 return snd_compress_wait_for_drain(stream); 791 } 792 793 static long snd_compr_ioctl(struct file *f, unsigned int cmd, unsigned long arg) 794 { 795 struct snd_compr_file *data = f->private_data; 796 struct snd_compr_stream *stream; 797 int retval = -ENOTTY; 798 799 if (snd_BUG_ON(!data)) 800 return -EFAULT; 801 stream = &data->stream; 802 if (snd_BUG_ON(!stream)) 803 return -EFAULT; 804 mutex_lock(&stream->device->lock); 805 switch (_IOC_NR(cmd)) { 806 case _IOC_NR(SNDRV_COMPRESS_IOCTL_VERSION): 807 retval = put_user(SNDRV_COMPRESS_VERSION, 808 (int __user *)arg) ? -EFAULT : 0; 809 break; 810 case _IOC_NR(SNDRV_COMPRESS_GET_CAPS): 811 retval = snd_compr_get_caps(stream, arg); 812 break; 813 #ifndef COMPR_CODEC_CAPS_OVERFLOW 814 case _IOC_NR(SNDRV_COMPRESS_GET_CODEC_CAPS): 815 retval = snd_compr_get_codec_caps(stream, arg); 816 break; 817 #endif 818 case _IOC_NR(SNDRV_COMPRESS_SET_PARAMS): 819 retval = snd_compr_set_params(stream, arg); 820 break; 821 case _IOC_NR(SNDRV_COMPRESS_GET_PARAMS): 822 retval = snd_compr_get_params(stream, arg); 823 break; 824 case _IOC_NR(SNDRV_COMPRESS_SET_METADATA): 825 retval = snd_compr_set_metadata(stream, arg); 826 break; 827 case _IOC_NR(SNDRV_COMPRESS_GET_METADATA): 828 retval = snd_compr_get_metadata(stream, arg); 829 break; 830 case _IOC_NR(SNDRV_COMPRESS_TSTAMP): 831 retval = snd_compr_tstamp(stream, arg); 832 break; 833 case _IOC_NR(SNDRV_COMPRESS_AVAIL): 834 retval = snd_compr_ioctl_avail(stream, arg); 835 break; 836 case _IOC_NR(SNDRV_COMPRESS_PAUSE): 837 retval = snd_compr_pause(stream); 838 break; 839 case _IOC_NR(SNDRV_COMPRESS_RESUME): 840 retval = snd_compr_resume(stream); 841 break; 842 case _IOC_NR(SNDRV_COMPRESS_START): 843 retval = snd_compr_start(stream); 844 break; 845 case _IOC_NR(SNDRV_COMPRESS_STOP): 846 retval = snd_compr_stop(stream); 847 break; 848 case _IOC_NR(SNDRV_COMPRESS_DRAIN): 849 retval = snd_compr_drain(stream); 850 break; 851 case _IOC_NR(SNDRV_COMPRESS_PARTIAL_DRAIN): 852 retval = snd_compr_partial_drain(stream); 853 break; 854 case _IOC_NR(SNDRV_COMPRESS_NEXT_TRACK): 855 retval = snd_compr_next_track(stream); 856 break; 857 858 } 859 mutex_unlock(&stream->device->lock); 860 return retval; 861 } 862 863 /* support of 32bit userspace on 64bit platforms */ 864 #ifdef CONFIG_COMPAT 865 static long snd_compr_ioctl_compat(struct file *file, unsigned int cmd, 866 unsigned long arg) 867 { 868 return snd_compr_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); 869 } 870 #endif 871 872 static const struct file_operations snd_compr_file_ops = { 873 .owner = THIS_MODULE, 874 .open = snd_compr_open, 875 .release = snd_compr_free, 876 .write = snd_compr_write, 877 .read = snd_compr_read, 878 .unlocked_ioctl = snd_compr_ioctl, 879 #ifdef CONFIG_COMPAT 880 .compat_ioctl = snd_compr_ioctl_compat, 881 #endif 882 .mmap = snd_compr_mmap, 883 .poll = snd_compr_poll, 884 }; 885 886 static int snd_compress_dev_register(struct snd_device *device) 887 { 888 int ret = -EINVAL; 889 char str[16]; 890 struct snd_compr *compr; 891 892 if (snd_BUG_ON(!device || !device->device_data)) 893 return -EBADFD; 894 compr = device->device_data; 895 896 pr_debug("reg %s for device %s, direction %d\n", str, compr->name, 897 compr->direction); 898 /* register compressed device */ 899 ret = snd_register_device(SNDRV_DEVICE_TYPE_COMPRESS, 900 compr->card, compr->device, 901 &snd_compr_file_ops, compr, &compr->dev); 902 if (ret < 0) { 903 pr_err("snd_register_device failed\n %d", ret); 904 return ret; 905 } 906 return ret; 907 908 } 909 910 static int snd_compress_dev_disconnect(struct snd_device *device) 911 { 912 struct snd_compr *compr; 913 914 compr = device->device_data; 915 snd_unregister_device(&compr->dev); 916 return 0; 917 } 918 919 #ifdef CONFIG_SND_VERBOSE_PROCFS 920 static void snd_compress_proc_info_read(struct snd_info_entry *entry, 921 struct snd_info_buffer *buffer) 922 { 923 struct snd_compr *compr = (struct snd_compr *)entry->private_data; 924 925 snd_iprintf(buffer, "card: %d\n", compr->card->number); 926 snd_iprintf(buffer, "device: %d\n", compr->device); 927 snd_iprintf(buffer, "stream: %s\n", 928 compr->direction == SND_COMPRESS_PLAYBACK 929 ? "PLAYBACK" : "CAPTURE"); 930 snd_iprintf(buffer, "id: %s\n", compr->id); 931 } 932 933 static int snd_compress_proc_init(struct snd_compr *compr) 934 { 935 struct snd_info_entry *entry; 936 char name[16]; 937 938 sprintf(name, "compr%i", compr->device); 939 entry = snd_info_create_card_entry(compr->card, name, 940 compr->card->proc_root); 941 if (!entry) 942 return -ENOMEM; 943 entry->mode = S_IFDIR | S_IRUGO | S_IXUGO; 944 if (snd_info_register(entry) < 0) { 945 snd_info_free_entry(entry); 946 return -ENOMEM; 947 } 948 compr->proc_root = entry; 949 950 entry = snd_info_create_card_entry(compr->card, "info", 951 compr->proc_root); 952 if (entry) { 953 snd_info_set_text_ops(entry, compr, 954 snd_compress_proc_info_read); 955 if (snd_info_register(entry) < 0) { 956 snd_info_free_entry(entry); 957 entry = NULL; 958 } 959 } 960 compr->proc_info_entry = entry; 961 962 return 0; 963 } 964 965 static void snd_compress_proc_done(struct snd_compr *compr) 966 { 967 snd_info_free_entry(compr->proc_info_entry); 968 compr->proc_info_entry = NULL; 969 snd_info_free_entry(compr->proc_root); 970 compr->proc_root = NULL; 971 } 972 973 static inline void snd_compress_set_id(struct snd_compr *compr, const char *id) 974 { 975 strlcpy(compr->id, id, sizeof(compr->id)); 976 } 977 #else 978 static inline int snd_compress_proc_init(struct snd_compr *compr) 979 { 980 return 0; 981 } 982 983 static inline void snd_compress_proc_done(struct snd_compr *compr) 984 { 985 } 986 987 static inline void snd_compress_set_id(struct snd_compr *compr, const char *id) 988 { 989 } 990 #endif 991 992 static int snd_compress_dev_free(struct snd_device *device) 993 { 994 struct snd_compr *compr; 995 996 compr = device->device_data; 997 snd_compress_proc_done(compr); 998 put_device(&compr->dev); 999 return 0; 1000 } 1001 1002 /* 1003 * snd_compress_new: create new compress device 1004 * @card: sound card pointer 1005 * @device: device number 1006 * @dirn: device direction, should be of type enum snd_compr_direction 1007 * @compr: compress device pointer 1008 */ 1009 int snd_compress_new(struct snd_card *card, int device, 1010 int dirn, const char *id, struct snd_compr *compr) 1011 { 1012 static struct snd_device_ops ops = { 1013 .dev_free = snd_compress_dev_free, 1014 .dev_register = snd_compress_dev_register, 1015 .dev_disconnect = snd_compress_dev_disconnect, 1016 }; 1017 int ret; 1018 1019 compr->card = card; 1020 compr->device = device; 1021 compr->direction = dirn; 1022 1023 snd_compress_set_id(compr, id); 1024 1025 snd_device_initialize(&compr->dev, card); 1026 dev_set_name(&compr->dev, "comprC%iD%i", card->number, device); 1027 1028 ret = snd_device_new(card, SNDRV_DEV_COMPRESS, compr, &ops); 1029 if (ret == 0) 1030 snd_compress_proc_init(compr); 1031 1032 return ret; 1033 } 1034 EXPORT_SYMBOL_GPL(snd_compress_new); 1035 1036 static int snd_compress_add_device(struct snd_compr *device) 1037 { 1038 int ret; 1039 1040 if (!device->card) 1041 return -EINVAL; 1042 1043 /* register the card */ 1044 ret = snd_card_register(device->card); 1045 if (ret) 1046 goto out; 1047 return 0; 1048 1049 out: 1050 pr_err("failed with %d\n", ret); 1051 return ret; 1052 1053 } 1054 1055 static int snd_compress_remove_device(struct snd_compr *device) 1056 { 1057 return snd_card_free(device->card); 1058 } 1059 1060 /** 1061 * snd_compress_register - register compressed device 1062 * 1063 * @device: compressed device to register 1064 */ 1065 int snd_compress_register(struct snd_compr *device) 1066 { 1067 int retval; 1068 1069 if (device->name == NULL || device->ops == NULL) 1070 return -EINVAL; 1071 1072 pr_debug("Registering compressed device %s\n", device->name); 1073 if (snd_BUG_ON(!device->ops->open)) 1074 return -EINVAL; 1075 if (snd_BUG_ON(!device->ops->free)) 1076 return -EINVAL; 1077 if (snd_BUG_ON(!device->ops->set_params)) 1078 return -EINVAL; 1079 if (snd_BUG_ON(!device->ops->trigger)) 1080 return -EINVAL; 1081 1082 mutex_init(&device->lock); 1083 1084 /* register a compressed card */ 1085 mutex_lock(&device_mutex); 1086 retval = snd_compress_add_device(device); 1087 mutex_unlock(&device_mutex); 1088 return retval; 1089 } 1090 EXPORT_SYMBOL_GPL(snd_compress_register); 1091 1092 int snd_compress_deregister(struct snd_compr *device) 1093 { 1094 pr_debug("Removing compressed device %s\n", device->name); 1095 mutex_lock(&device_mutex); 1096 snd_compress_remove_device(device); 1097 mutex_unlock(&device_mutex); 1098 return 0; 1099 } 1100 EXPORT_SYMBOL_GPL(snd_compress_deregister); 1101 1102 static int __init snd_compress_init(void) 1103 { 1104 return 0; 1105 } 1106 1107 static void __exit snd_compress_exit(void) 1108 { 1109 } 1110 1111 module_init(snd_compress_init); 1112 module_exit(snd_compress_exit); 1113 1114 MODULE_DESCRIPTION("ALSA Compressed offload framework"); 1115 MODULE_AUTHOR("Vinod Koul <vinod.koul@linux.intel.com>"); 1116 MODULE_LICENSE("GPL v2"); 1117