sound/core/compress_offload.c

   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");