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 <sound/core.h> 42 #include <sound/initval.h> 43 #include <sound/compress_params.h> 44 #include <sound/compress_offload.h> 45 #include <sound/compress_driver.h> 46 47 /* TODO: 48 * - add substream support for multiple devices in case of 49 * SND_DYNAMIC_MINORS is not used 50 * - Multiple node representation 51 * driver should be able to register multiple nodes 52 */ 53 54 static DEFINE_MUTEX(device_mutex); 55 56 struct snd_compr_file { 57 unsigned long caps; 58 struct snd_compr_stream stream; 59 }; 60 61 /* 62 * a note on stream states used: 63 * we use follwing states in the compressed core 64 * SNDRV_PCM_STATE_OPEN: When stream has been opened. 65 * SNDRV_PCM_STATE_SETUP: When stream has been initialized. This is done by 66 * calling SNDRV_COMPRESS_SET_PARAMS. running streams will come to this 67 * state at stop by calling SNDRV_COMPRESS_STOP, or at end of drain. 68 * SNDRV_PCM_STATE_RUNNING: When stream has been started and is 69 * decoding/encoding and rendering/capturing data. 70 * SNDRV_PCM_STATE_DRAINING: When stream is draining current data. This is done 71 * by calling SNDRV_COMPRESS_DRAIN. 72 * SNDRV_PCM_STATE_PAUSED: When stream is paused. This is done by calling 73 * SNDRV_COMPRESS_PAUSE. It can be stopped or resumed by calling 74 * SNDRV_COMPRESS_STOP or SNDRV_COMPRESS_RESUME respectively. 75 */ 76 static int snd_compr_open(struct inode *inode, struct file *f) 77 { 78 struct snd_compr *compr; 79 struct snd_compr_file *data; 80 struct snd_compr_runtime *runtime; 81 enum snd_compr_direction dirn; 82 int maj = imajor(inode); 83 int ret; 84 85 if ((f->f_flags & O_ACCMODE) == O_WRONLY) 86 dirn = SND_COMPRESS_PLAYBACK; 87 else if ((f->f_flags & O_ACCMODE) == O_RDONLY) 88 dirn = SND_COMPRESS_CAPTURE; 89 else 90 return -EINVAL; 91 92 if (maj == snd_major) 93 compr = snd_lookup_minor_data(iminor(inode), 94 SNDRV_DEVICE_TYPE_COMPRESS); 95 else 96 return -EBADFD; 97 98 if (compr == NULL) { 99 pr_err("no device data!!!\n"); 100 return -ENODEV; 101 } 102 103 if (dirn != compr->direction) { 104 pr_err("this device doesn't support this direction\n"); 105 snd_card_unref(compr->card); 106 return -EINVAL; 107 } 108 109 data = kzalloc(sizeof(*data), GFP_KERNEL); 110 if (!data) { 111 snd_card_unref(compr->card); 112 return -ENOMEM; 113 } 114 data->stream.ops = compr->ops; 115 data->stream.direction = dirn; 116 data->stream.private_data = compr->private_data; 117 data->stream.device = compr; 118 runtime = kzalloc(sizeof(*runtime), GFP_KERNEL); 119 if (!runtime) { 120 kfree(data); 121 snd_card_unref(compr->card); 122 return -ENOMEM; 123 } 124 runtime->state = SNDRV_PCM_STATE_OPEN; 125 init_waitqueue_head(&runtime->sleep); 126 data->stream.runtime = runtime; 127 f->private_data = (void *)data; 128 mutex_lock(&compr->lock); 129 ret = compr->ops->open(&data->stream); 130 mutex_unlock(&compr->lock); 131 if (ret) { 132 kfree(runtime); 133 kfree(data); 134 } 135 snd_card_unref(compr->card); 136 return 0; 137 } 138 139 static int snd_compr_free(struct inode *inode, struct file *f) 140 { 141 struct snd_compr_file *data = f->private_data; 142 struct snd_compr_runtime *runtime = data->stream.runtime; 143 144 switch (runtime->state) { 145 case SNDRV_PCM_STATE_RUNNING: 146 case SNDRV_PCM_STATE_DRAINING: 147 case SNDRV_PCM_STATE_PAUSED: 148 data->stream.ops->trigger(&data->stream, SNDRV_PCM_TRIGGER_STOP); 149 break; 150 default: 151 break; 152 } 153 154 data->stream.ops->free(&data->stream); 155 kfree(data->stream.runtime->buffer); 156 kfree(data->stream.runtime); 157 kfree(data); 158 return 0; 159 } 160 161 static int snd_compr_update_tstamp(struct snd_compr_stream *stream, 162 struct snd_compr_tstamp *tstamp) 163 { 164 if (!stream->ops->pointer) 165 return -ENOTSUPP; 166 stream->ops->pointer(stream, tstamp); 167 pr_debug("dsp consumed till %d total %d bytes\n", 168 tstamp->byte_offset, tstamp->copied_total); 169 if (stream->direction == SND_COMPRESS_PLAYBACK) 170 stream->runtime->total_bytes_transferred = tstamp->copied_total; 171 else 172 stream->runtime->total_bytes_available = tstamp->copied_total; 173 return 0; 174 } 175 176 static size_t snd_compr_calc_avail(struct snd_compr_stream *stream, 177 struct snd_compr_avail *avail) 178 { 179 memset(avail, 0, sizeof(*avail)); 180 snd_compr_update_tstamp(stream, &avail->tstamp); 181 /* Still need to return avail even if tstamp can't be filled in */ 182 183 if (stream->runtime->total_bytes_available == 0 && 184 stream->runtime->state == SNDRV_PCM_STATE_SETUP && 185 stream->direction == SND_COMPRESS_PLAYBACK) { 186 pr_debug("detected init and someone forgot to do a write\n"); 187 return stream->runtime->buffer_size; 188 } 189 pr_debug("app wrote %lld, DSP consumed %lld\n", 190 stream->runtime->total_bytes_available, 191 stream->runtime->total_bytes_transferred); 192 if (stream->runtime->total_bytes_available == 193 stream->runtime->total_bytes_transferred) { 194 if (stream->direction == SND_COMPRESS_PLAYBACK) { 195 pr_debug("both pointers are same, returning full avail\n"); 196 return stream->runtime->buffer_size; 197 } else { 198 pr_debug("both pointers are same, returning no avail\n"); 199 return 0; 200 } 201 } 202 203 avail->avail = stream->runtime->total_bytes_available - 204 stream->runtime->total_bytes_transferred; 205 if (stream->direction == SND_COMPRESS_PLAYBACK) 206 avail->avail = stream->runtime->buffer_size - avail->avail; 207 208 pr_debug("ret avail as %lld\n", avail->avail); 209 return avail->avail; 210 } 211 212 static inline size_t snd_compr_get_avail(struct snd_compr_stream *stream) 213 { 214 struct snd_compr_avail avail; 215 216 return snd_compr_calc_avail(stream, &avail); 217 } 218 219 static int 220 snd_compr_ioctl_avail(struct snd_compr_stream *stream, unsigned long arg) 221 { 222 struct snd_compr_avail ioctl_avail; 223 size_t avail; 224 225 avail = snd_compr_calc_avail(stream, &ioctl_avail); 226 ioctl_avail.avail = avail; 227 228 if (copy_to_user((__u64 __user *)arg, 229 &ioctl_avail, sizeof(ioctl_avail))) 230 return -EFAULT; 231 return 0; 232 } 233 234 static int snd_compr_write_data(struct snd_compr_stream *stream, 235 const char __user *buf, size_t count) 236 { 237 void *dstn; 238 size_t copy; 239 struct snd_compr_runtime *runtime = stream->runtime; 240 /* 64-bit Modulus */ 241 u64 app_pointer = div64_u64(runtime->total_bytes_available, 242 runtime->buffer_size); 243 app_pointer = runtime->total_bytes_available - 244 (app_pointer * runtime->buffer_size); 245 246 dstn = runtime->buffer + app_pointer; 247 pr_debug("copying %ld at %lld\n", 248 (unsigned long)count, app_pointer); 249 if (count < runtime->buffer_size - app_pointer) { 250 if (copy_from_user(dstn, buf, count)) 251 return -EFAULT; 252 } else { 253 copy = runtime->buffer_size - app_pointer; 254 if (copy_from_user(dstn, buf, copy)) 255 return -EFAULT; 256 if (copy_from_user(runtime->buffer, buf + copy, count - copy)) 257 return -EFAULT; 258 } 259 /* if DSP cares, let it know data has been written */ 260 if (stream->ops->ack) 261 stream->ops->ack(stream, count); 262 return count; 263 } 264 265 static ssize_t snd_compr_write(struct file *f, const char __user *buf, 266 size_t count, loff_t *offset) 267 { 268 struct snd_compr_file *data = f->private_data; 269 struct snd_compr_stream *stream; 270 size_t avail; 271 int retval; 272 273 if (snd_BUG_ON(!data)) 274 return -EFAULT; 275 276 stream = &data->stream; 277 mutex_lock(&stream->device->lock); 278 /* write is allowed when stream is running or has been steup */ 279 if (stream->runtime->state != SNDRV_PCM_STATE_SETUP && 280 stream->runtime->state != SNDRV_PCM_STATE_RUNNING) { 281 mutex_unlock(&stream->device->lock); 282 return -EBADFD; 283 } 284 285 avail = snd_compr_get_avail(stream); 286 pr_debug("avail returned %ld\n", (unsigned long)avail); 287 /* calculate how much we can write to buffer */ 288 if (avail > count) 289 avail = count; 290 291 if (stream->ops->copy) { 292 char __user* cbuf = (char __user*)buf; 293 retval = stream->ops->copy(stream, cbuf, avail); 294 } else { 295 retval = snd_compr_write_data(stream, buf, avail); 296 } 297 if (retval > 0) 298 stream->runtime->total_bytes_available += retval; 299 300 /* while initiating the stream, write should be called before START 301 * call, so in setup move state */ 302 if (stream->runtime->state == SNDRV_PCM_STATE_SETUP) { 303 stream->runtime->state = SNDRV_PCM_STATE_PREPARED; 304 pr_debug("stream prepared, Houston we are good to go\n"); 305 } 306 307 mutex_unlock(&stream->device->lock); 308 return retval; 309 } 310 311 312 static ssize_t snd_compr_read(struct file *f, char __user *buf, 313 size_t count, loff_t *offset) 314 { 315 struct snd_compr_file *data = f->private_data; 316 struct snd_compr_stream *stream; 317 size_t avail; 318 int retval; 319 320 if (snd_BUG_ON(!data)) 321 return -EFAULT; 322 323 stream = &data->stream; 324 mutex_lock(&stream->device->lock); 325 326 /* read is allowed when stream is running, paused, draining and setup 327 * (yes setup is state which we transition to after stop, so if user 328 * wants to read data after stop we allow that) 329 */ 330 switch (stream->runtime->state) { 331 case SNDRV_PCM_STATE_OPEN: 332 case SNDRV_PCM_STATE_PREPARED: 333 case SNDRV_PCM_STATE_XRUN: 334 case SNDRV_PCM_STATE_SUSPENDED: 335 case SNDRV_PCM_STATE_DISCONNECTED: 336 retval = -EBADFD; 337 goto out; 338 } 339 340 avail = snd_compr_get_avail(stream); 341 pr_debug("avail returned %ld\n", (unsigned long)avail); 342 /* calculate how much we can read from buffer */ 343 if (avail > count) 344 avail = count; 345 346 if (stream->ops->copy) { 347 retval = stream->ops->copy(stream, buf, avail); 348 } else { 349 retval = -ENXIO; 350 goto out; 351 } 352 if (retval > 0) 353 stream->runtime->total_bytes_transferred += retval; 354 355 out: 356 mutex_unlock(&stream->device->lock); 357 return retval; 358 } 359 360 static int snd_compr_mmap(struct file *f, struct vm_area_struct *vma) 361 { 362 return -ENXIO; 363 } 364 365 static inline int snd_compr_get_poll(struct snd_compr_stream *stream) 366 { 367 if (stream->direction == SND_COMPRESS_PLAYBACK) 368 return POLLOUT | POLLWRNORM; 369 else 370 return POLLIN | POLLRDNORM; 371 } 372 373 static unsigned int snd_compr_poll(struct file *f, poll_table *wait) 374 { 375 struct snd_compr_file *data = f->private_data; 376 struct snd_compr_stream *stream; 377 size_t avail; 378 int retval = 0; 379 380 if (snd_BUG_ON(!data)) 381 return -EFAULT; 382 stream = &data->stream; 383 if (snd_BUG_ON(!stream)) 384 return -EFAULT; 385 386 mutex_lock(&stream->device->lock); 387 if (stream->runtime->state == SNDRV_PCM_STATE_PAUSED || 388 stream->runtime->state == SNDRV_PCM_STATE_OPEN) { 389 retval = -EBADFD; 390 goto out; 391 } 392 poll_wait(f, &stream->runtime->sleep, wait); 393 394 avail = snd_compr_get_avail(stream); 395 pr_debug("avail is %ld\n", (unsigned long)avail); 396 /* check if we have at least one fragment to fill */ 397 switch (stream->runtime->state) { 398 case SNDRV_PCM_STATE_DRAINING: 399 /* stream has been woken up after drain is complete 400 * draining done so set stream state to stopped 401 */ 402 retval = snd_compr_get_poll(stream); 403 stream->runtime->state = SNDRV_PCM_STATE_SETUP; 404 break; 405 case SNDRV_PCM_STATE_RUNNING: 406 case SNDRV_PCM_STATE_PREPARED: 407 case SNDRV_PCM_STATE_PAUSED: 408 if (avail >= stream->runtime->fragment_size) 409 retval = snd_compr_get_poll(stream); 410 break; 411 default: 412 if (stream->direction == SND_COMPRESS_PLAYBACK) 413 retval = POLLOUT | POLLWRNORM | POLLERR; 414 else 415 retval = POLLIN | POLLRDNORM | POLLERR; 416 break; 417 } 418 out: 419 mutex_unlock(&stream->device->lock); 420 return retval; 421 } 422 423 static int 424 snd_compr_get_caps(struct snd_compr_stream *stream, unsigned long arg) 425 { 426 int retval; 427 struct snd_compr_caps caps; 428 429 if (!stream->ops->get_caps) 430 return -ENXIO; 431 432 memset(&caps, 0, sizeof(caps)); 433 retval = stream->ops->get_caps(stream, &caps); 434 if (retval) 435 goto out; 436 if (copy_to_user((void __user *)arg, &caps, sizeof(caps))) 437 retval = -EFAULT; 438 out: 439 return retval; 440 } 441 442 static int 443 snd_compr_get_codec_caps(struct snd_compr_stream *stream, unsigned long arg) 444 { 445 int retval; 446 struct snd_compr_codec_caps *caps; 447 448 if (!stream->ops->get_codec_caps) 449 return -ENXIO; 450 451 caps = kzalloc(sizeof(*caps), GFP_KERNEL); 452 if (!caps) 453 return -ENOMEM; 454 455 retval = stream->ops->get_codec_caps(stream, caps); 456 if (retval) 457 goto out; 458 if (copy_to_user((void __user *)arg, caps, sizeof(*caps))) 459 retval = -EFAULT; 460 461 out: 462 kfree(caps); 463 return retval; 464 } 465 466 /* revisit this with snd_pcm_preallocate_xxx */ 467 static int snd_compr_allocate_buffer(struct snd_compr_stream *stream, 468 struct snd_compr_params *params) 469 { 470 unsigned int buffer_size; 471 void *buffer; 472 473 buffer_size = params->buffer.fragment_size * params->buffer.fragments; 474 if (stream->ops->copy) { 475 buffer = NULL; 476 /* if copy is defined the driver will be required to copy 477 * the data from core 478 */ 479 } else { 480 buffer = kmalloc(buffer_size, GFP_KERNEL); 481 if (!buffer) 482 return -ENOMEM; 483 } 484 stream->runtime->fragment_size = params->buffer.fragment_size; 485 stream->runtime->fragments = params->buffer.fragments; 486 stream->runtime->buffer = buffer; 487 stream->runtime->buffer_size = buffer_size; 488 return 0; 489 } 490 491 static int snd_compress_check_input(struct snd_compr_params *params) 492 { 493 /* first let's check the buffer parameter's */ 494 if (params->buffer.fragment_size == 0 || 495 params->buffer.fragments > SIZE_MAX / params->buffer.fragment_size) 496 return -EINVAL; 497 498 /* now codec parameters */ 499 if (params->codec.id == 0 || params->codec.id > SND_AUDIOCODEC_MAX) 500 return -EINVAL; 501 502 if (params->codec.ch_in == 0 || params->codec.ch_out == 0) 503 return -EINVAL; 504 505 if (!(params->codec.sample_rate & SNDRV_PCM_RATE_8000_192000)) 506 return -EINVAL; 507 508 return 0; 509 } 510 511 static int 512 snd_compr_set_params(struct snd_compr_stream *stream, unsigned long arg) 513 { 514 struct snd_compr_params *params; 515 int retval; 516 517 if (stream->runtime->state == SNDRV_PCM_STATE_OPEN) { 518 /* 519 * we should allow parameter change only when stream has been 520 * opened not in other cases 521 */ 522 params = kmalloc(sizeof(*params), GFP_KERNEL); 523 if (!params) 524 return -ENOMEM; 525 if (copy_from_user(params, (void __user *)arg, sizeof(*params))) { 526 retval = -EFAULT; 527 goto out; 528 } 529 530 retval = snd_compress_check_input(params); 531 if (retval) 532 goto out; 533 534 retval = snd_compr_allocate_buffer(stream, params); 535 if (retval) { 536 retval = -ENOMEM; 537 goto out; 538 } 539 540 retval = stream->ops->set_params(stream, params); 541 if (retval) 542 goto out; 543 544 stream->metadata_set = false; 545 stream->next_track = false; 546 547 if (stream->direction == SND_COMPRESS_PLAYBACK) 548 stream->runtime->state = SNDRV_PCM_STATE_SETUP; 549 else 550 stream->runtime->state = SNDRV_PCM_STATE_PREPARED; 551 } else { 552 return -EPERM; 553 } 554 out: 555 kfree(params); 556 return retval; 557 } 558 559 static int 560 snd_compr_get_params(struct snd_compr_stream *stream, unsigned long arg) 561 { 562 struct snd_codec *params; 563 int retval; 564 565 if (!stream->ops->get_params) 566 return -EBADFD; 567 568 params = kzalloc(sizeof(*params), GFP_KERNEL); 569 if (!params) 570 return -ENOMEM; 571 retval = stream->ops->get_params(stream, params); 572 if (retval) 573 goto out; 574 if (copy_to_user((char __user *)arg, params, sizeof(*params))) 575 retval = -EFAULT; 576 577 out: 578 kfree(params); 579 return retval; 580 } 581 582 static int 583 snd_compr_get_metadata(struct snd_compr_stream *stream, unsigned long arg) 584 { 585 struct snd_compr_metadata metadata; 586 int retval; 587 588 if (!stream->ops->get_metadata) 589 return -ENXIO; 590 591 if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata))) 592 return -EFAULT; 593 594 retval = stream->ops->get_metadata(stream, &metadata); 595 if (retval != 0) 596 return retval; 597 598 if (copy_to_user((void __user *)arg, &metadata, sizeof(metadata))) 599 return -EFAULT; 600 601 return 0; 602 } 603 604 static int 605 snd_compr_set_metadata(struct snd_compr_stream *stream, unsigned long arg) 606 { 607 struct snd_compr_metadata metadata; 608 int retval; 609 610 if (!stream->ops->set_metadata) 611 return -ENXIO; 612 /* 613 * we should allow parameter change only when stream has been 614 * opened not in other cases 615 */ 616 if (copy_from_user(&metadata, (void __user *)arg, sizeof(metadata))) 617 return -EFAULT; 618 619 retval = stream->ops->set_metadata(stream, &metadata); 620 stream->metadata_set = true; 621 622 return retval; 623 } 624 625 static inline int 626 snd_compr_tstamp(struct snd_compr_stream *stream, unsigned long arg) 627 { 628 struct snd_compr_tstamp tstamp = {0}; 629 int ret; 630 631 ret = snd_compr_update_tstamp(stream, &tstamp); 632 if (ret == 0) 633 ret = copy_to_user((struct snd_compr_tstamp __user *)arg, 634 &tstamp, sizeof(tstamp)) ? -EFAULT : 0; 635 return ret; 636 } 637 638 static int snd_compr_pause(struct snd_compr_stream *stream) 639 { 640 int retval; 641 642 if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING) 643 return -EPERM; 644 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_PUSH); 645 if (!retval) 646 stream->runtime->state = SNDRV_PCM_STATE_PAUSED; 647 return retval; 648 } 649 650 static int snd_compr_resume(struct snd_compr_stream *stream) 651 { 652 int retval; 653 654 if (stream->runtime->state != SNDRV_PCM_STATE_PAUSED) 655 return -EPERM; 656 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_PAUSE_RELEASE); 657 if (!retval) 658 stream->runtime->state = SNDRV_PCM_STATE_RUNNING; 659 return retval; 660 } 661 662 static int snd_compr_start(struct snd_compr_stream *stream) 663 { 664 int retval; 665 666 if (stream->runtime->state != SNDRV_PCM_STATE_PREPARED) 667 return -EPERM; 668 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_START); 669 if (!retval) 670 stream->runtime->state = SNDRV_PCM_STATE_RUNNING; 671 return retval; 672 } 673 674 static int snd_compr_stop(struct snd_compr_stream *stream) 675 { 676 int retval; 677 678 if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED || 679 stream->runtime->state == SNDRV_PCM_STATE_SETUP) 680 return -EPERM; 681 retval = stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_STOP); 682 if (!retval) { 683 stream->runtime->state = SNDRV_PCM_STATE_SETUP; 684 wake_up(&stream->runtime->sleep); 685 stream->runtime->total_bytes_available = 0; 686 stream->runtime->total_bytes_transferred = 0; 687 } 688 return retval; 689 } 690 691 static int snd_compr_drain(struct snd_compr_stream *stream) 692 { 693 int retval; 694 695 if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED || 696 stream->runtime->state == SNDRV_PCM_STATE_SETUP) 697 return -EPERM; 698 retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_DRAIN); 699 if (!retval) { 700 stream->runtime->state = SNDRV_PCM_STATE_DRAINING; 701 wake_up(&stream->runtime->sleep); 702 } 703 return retval; 704 } 705 706 static int snd_compr_next_track(struct snd_compr_stream *stream) 707 { 708 int retval; 709 710 /* only a running stream can transition to next track */ 711 if (stream->runtime->state != SNDRV_PCM_STATE_RUNNING) 712 return -EPERM; 713 714 /* you can signal next track isf this is intended to be a gapless stream 715 * and current track metadata is set 716 */ 717 if (stream->metadata_set == false) 718 return -EPERM; 719 720 retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_NEXT_TRACK); 721 if (retval != 0) 722 return retval; 723 stream->metadata_set = false; 724 stream->next_track = true; 725 return 0; 726 } 727 728 static int snd_compr_partial_drain(struct snd_compr_stream *stream) 729 { 730 int retval; 731 if (stream->runtime->state == SNDRV_PCM_STATE_PREPARED || 732 stream->runtime->state == SNDRV_PCM_STATE_SETUP) 733 return -EPERM; 734 /* stream can be drained only when next track has been signalled */ 735 if (stream->next_track == false) 736 return -EPERM; 737 738 retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_PARTIAL_DRAIN); 739 740 stream->next_track = false; 741 return retval; 742 } 743 744 static long snd_compr_ioctl(struct file *f, unsigned int cmd, unsigned long arg) 745 { 746 struct snd_compr_file *data = f->private_data; 747 struct snd_compr_stream *stream; 748 int retval = -ENOTTY; 749 750 if (snd_BUG_ON(!data)) 751 return -EFAULT; 752 stream = &data->stream; 753 if (snd_BUG_ON(!stream)) 754 return -EFAULT; 755 mutex_lock(&stream->device->lock); 756 switch (_IOC_NR(cmd)) { 757 case _IOC_NR(SNDRV_COMPRESS_IOCTL_VERSION): 758 retval = put_user(SNDRV_COMPRESS_VERSION, 759 (int __user *)arg) ? -EFAULT : 0; 760 break; 761 case _IOC_NR(SNDRV_COMPRESS_GET_CAPS): 762 retval = snd_compr_get_caps(stream, arg); 763 break; 764 case _IOC_NR(SNDRV_COMPRESS_GET_CODEC_CAPS): 765 retval = snd_compr_get_codec_caps(stream, arg); 766 break; 767 case _IOC_NR(SNDRV_COMPRESS_SET_PARAMS): 768 retval = snd_compr_set_params(stream, arg); 769 break; 770 case _IOC_NR(SNDRV_COMPRESS_GET_PARAMS): 771 retval = snd_compr_get_params(stream, arg); 772 break; 773 case _IOC_NR(SNDRV_COMPRESS_SET_METADATA): 774 retval = snd_compr_set_metadata(stream, arg); 775 break; 776 case _IOC_NR(SNDRV_COMPRESS_GET_METADATA): 777 retval = snd_compr_get_metadata(stream, arg); 778 break; 779 case _IOC_NR(SNDRV_COMPRESS_TSTAMP): 780 retval = snd_compr_tstamp(stream, arg); 781 break; 782 case _IOC_NR(SNDRV_COMPRESS_AVAIL): 783 retval = snd_compr_ioctl_avail(stream, arg); 784 break; 785 case _IOC_NR(SNDRV_COMPRESS_PAUSE): 786 retval = snd_compr_pause(stream); 787 break; 788 case _IOC_NR(SNDRV_COMPRESS_RESUME): 789 retval = snd_compr_resume(stream); 790 break; 791 case _IOC_NR(SNDRV_COMPRESS_START): 792 retval = snd_compr_start(stream); 793 break; 794 case _IOC_NR(SNDRV_COMPRESS_STOP): 795 retval = snd_compr_stop(stream); 796 break; 797 case _IOC_NR(SNDRV_COMPRESS_DRAIN): 798 retval = snd_compr_drain(stream); 799 break; 800 case _IOC_NR(SNDRV_COMPRESS_PARTIAL_DRAIN): 801 retval = snd_compr_partial_drain(stream); 802 break; 803 case _IOC_NR(SNDRV_COMPRESS_NEXT_TRACK): 804 retval = snd_compr_next_track(stream); 805 break; 806 807 } 808 mutex_unlock(&stream->device->lock); 809 return retval; 810 } 811 812 static const struct file_operations snd_compr_file_ops = { 813 .owner = THIS_MODULE, 814 .open = snd_compr_open, 815 .release = snd_compr_free, 816 .write = snd_compr_write, 817 .read = snd_compr_read, 818 .unlocked_ioctl = snd_compr_ioctl, 819 .mmap = snd_compr_mmap, 820 .poll = snd_compr_poll, 821 }; 822 823 static int snd_compress_dev_register(struct snd_device *device) 824 { 825 int ret = -EINVAL; 826 char str[16]; 827 struct snd_compr *compr; 828 829 if (snd_BUG_ON(!device || !device->device_data)) 830 return -EBADFD; 831 compr = device->device_data; 832 833 sprintf(str, "comprC%iD%i", compr->card->number, compr->device); 834 pr_debug("reg %s for device %s, direction %d\n", str, compr->name, 835 compr->direction); 836 /* register compressed device */ 837 ret = snd_register_device(SNDRV_DEVICE_TYPE_COMPRESS, compr->card, 838 compr->device, &snd_compr_file_ops, compr, str); 839 if (ret < 0) { 840 pr_err("snd_register_device failed\n %d", ret); 841 return ret; 842 } 843 return ret; 844 845 } 846 847 static int snd_compress_dev_disconnect(struct snd_device *device) 848 { 849 struct snd_compr *compr; 850 851 compr = device->device_data; 852 snd_unregister_device(SNDRV_DEVICE_TYPE_COMPRESS, compr->card, 853 compr->device); 854 return 0; 855 } 856 857 /* 858 * snd_compress_new: create new compress device 859 * @card: sound card pointer 860 * @device: device number 861 * @dirn: device direction, should be of type enum snd_compr_direction 862 * @compr: compress device pointer 863 */ 864 int snd_compress_new(struct snd_card *card, int device, 865 int dirn, struct snd_compr *compr) 866 { 867 static struct snd_device_ops ops = { 868 .dev_free = NULL, 869 .dev_register = snd_compress_dev_register, 870 .dev_disconnect = snd_compress_dev_disconnect, 871 }; 872 873 compr->card = card; 874 compr->device = device; 875 compr->direction = dirn; 876 return snd_device_new(card, SNDRV_DEV_COMPRESS, compr, &ops); 877 } 878 EXPORT_SYMBOL_GPL(snd_compress_new); 879 880 static int snd_compress_add_device(struct snd_compr *device) 881 { 882 int ret; 883 884 if (!device->card) 885 return -EINVAL; 886 887 /* register the card */ 888 ret = snd_card_register(device->card); 889 if (ret) 890 goto out; 891 return 0; 892 893 out: 894 pr_err("failed with %d\n", ret); 895 return ret; 896 897 } 898 899 static int snd_compress_remove_device(struct snd_compr *device) 900 { 901 return snd_card_free(device->card); 902 } 903 904 /** 905 * snd_compress_register - register compressed device 906 * 907 * @device: compressed device to register 908 */ 909 int snd_compress_register(struct snd_compr *device) 910 { 911 int retval; 912 913 if (device->name == NULL || device->dev == NULL || device->ops == NULL) 914 return -EINVAL; 915 916 pr_debug("Registering compressed device %s\n", device->name); 917 if (snd_BUG_ON(!device->ops->open)) 918 return -EINVAL; 919 if (snd_BUG_ON(!device->ops->free)) 920 return -EINVAL; 921 if (snd_BUG_ON(!device->ops->set_params)) 922 return -EINVAL; 923 if (snd_BUG_ON(!device->ops->trigger)) 924 return -EINVAL; 925 926 mutex_init(&device->lock); 927 928 /* register a compressed card */ 929 mutex_lock(&device_mutex); 930 retval = snd_compress_add_device(device); 931 mutex_unlock(&device_mutex); 932 return retval; 933 } 934 EXPORT_SYMBOL_GPL(snd_compress_register); 935 936 int snd_compress_deregister(struct snd_compr *device) 937 { 938 pr_debug("Removing compressed device %s\n", device->name); 939 mutex_lock(&device_mutex); 940 snd_compress_remove_device(device); 941 mutex_unlock(&device_mutex); 942 return 0; 943 } 944 EXPORT_SYMBOL_GPL(snd_compress_deregister); 945 946 static int __init snd_compress_init(void) 947 { 948 return 0; 949 } 950 951 static void __exit snd_compress_exit(void) 952 { 953 } 954 955 module_init(snd_compress_init); 956 module_exit(snd_compress_exit); 957 958 MODULE_DESCRIPTION("ALSA Compressed offload framework"); 959 MODULE_AUTHOR("Vinod Koul <vinod.koul@linux.intel.com>"); 960 MODULE_LICENSE("GPL v2"); 961