sound/soc/intel/atom/sst/sst_drv_interface.c

   1 /*
   2  *  sst_drv_interface.c - Intel SST Driver for audio engine
   3  *
   4  *  Copyright (C) 2008-14 Intel Corp
   5  *  Authors:    Vinod Koul <vinod.koul@intel.com>
   6  *              Harsha Priya <priya.harsha@intel.com>
   7  *              Dharageswari R <dharageswari.r@intel.com)
   8  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; version 2 of the License.
  13  *
  14  *  This program is distributed in the hope that it will be useful, but
  15  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  *  General Public License for more details.
  18  *
  19  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  20  */
  21 #include <linux/delay.h>
  22 #include <linux/pci.h>
  23 #include <linux/fs.h>
  24 #include <linux/firmware.h>
  25 #include <linux/pm_runtime.h>
  26 #include <linux/pm_qos.h>
  27 #include <linux/math64.h>
  28 #include <sound/core.h>
  29 #include <sound/pcm.h>
  30 #include <sound/soc.h>
  31 #include <sound/compress_driver.h>
  32 #include <asm/platform_sst_audio.h>
  33 #include "../sst-mfld-platform.h"
  34 #include "sst.h"
  35 #include "../../common/sst-dsp.h"
  36
  37
  38
  39 #define NUM_CODEC 2
  40 #define MIN_FRAGMENT 2
  41 #define MAX_FRAGMENT 4
  42 #define MIN_FRAGMENT_SIZE (50 * 1024)
  43 #define MAX_FRAGMENT_SIZE (1024 * 1024)
  44 #define SST_GET_BYTES_PER_SAMPLE(pcm_wd_sz)  (((pcm_wd_sz + 15) >> 4) << 1)
  45 #ifdef CONFIG_PM
  46 #define GET_USAGE_COUNT(dev) (atomic_read(&dev->power.usage_count))
  47 #else
  48 #define GET_USAGE_COUNT(dev) 1
  49 #endif
  50
  51 int free_stream_context(struct intel_sst_drv *ctx, unsigned int str_id)
  52 {
  53         struct stream_info *stream;
  54         int ret = 0;
  55
  56         stream = get_stream_info(ctx, str_id);
  57         if (stream) {
  58                 /* str_id is valid, so stream is alloacted */
  59                 ret = sst_free_stream(ctx, str_id);
  60                 if (ret)
  61                         sst_clean_stream(&ctx->streams[str_id]);
  62                 return ret;
  63         } else {
  64                 dev_err(ctx->dev, "we tried to free stream context %d which was freed!!!\n", str_id);
  65         }
  66         return ret;
  67 }
  68
  69 int sst_get_stream_allocated(struct intel_sst_drv *ctx,
  70         struct snd_sst_params *str_param,
  71         struct snd_sst_lib_download **lib_dnld)
  72 {
  73         int retval;
  74
  75         retval = ctx->ops->alloc_stream(ctx, str_param);
  76         if (retval > 0)
  77                 dev_dbg(ctx->dev, "Stream allocated %d\n", retval);
  78         return retval;
  79
  80 }
  81
  82 /*
  83  * sst_get_sfreq - this function returns the frequency of the stream
  84  *
  85  * @str_param : stream params
  86  */
  87 int sst_get_sfreq(struct snd_sst_params *str_param)
  88 {
  89         switch (str_param->codec) {
  90         case SST_CODEC_TYPE_PCM:
  91                 return str_param->sparams.uc.pcm_params.sfreq;
  92         case SST_CODEC_TYPE_AAC:
  93                 return str_param->sparams.uc.aac_params.externalsr;
  94         case SST_CODEC_TYPE_MP3:
  95                 return 0;
  96         default:
  97                 return -EINVAL;
  98         }
  99 }
 100
 101 /*
 102  * sst_get_num_channel - get number of channels for the stream
 103  *
 104  * @str_param : stream params
 105  */
 106 int sst_get_num_channel(struct snd_sst_params *str_param)
 107 {
 108         switch (str_param->codec) {
 109         case SST_CODEC_TYPE_PCM:
 110                 return str_param->sparams.uc.pcm_params.num_chan;
 111         case SST_CODEC_TYPE_MP3:
 112                 return str_param->sparams.uc.mp3_params.num_chan;
 113         case SST_CODEC_TYPE_AAC:
 114                 return str_param->sparams.uc.aac_params.num_chan;
 115         default:
 116                 return -EINVAL;
 117         }
 118 }
 119
 120 /*
 121  * sst_get_stream - this function prepares for stream allocation
 122  *
 123  * @str_param : stream param
 124  */
 125 int sst_get_stream(struct intel_sst_drv *ctx,
 126                         struct snd_sst_params *str_param)
 127 {
 128         int retval;
 129         struct stream_info *str_info;
 130
 131         /* stream is not allocated, we are allocating */
 132         retval = ctx->ops->alloc_stream(ctx, str_param);
 133         if (retval <= 0) {
 134                 return -EIO;
 135         }
 136         /* store sampling freq */
 137         str_info = &ctx->streams[retval];
 138         str_info->sfreq = sst_get_sfreq(str_param);
 139
 140         return retval;
 141 }
 142
 143 static int sst_power_control(struct device *dev, bool state)
 144 {
 145         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 146         int ret = 0;
 147         int usage_count = 0;
 148
 149         if (state == true) {
 150                 ret = pm_runtime_get_sync(dev);
 151                 usage_count = GET_USAGE_COUNT(dev);
 152                 dev_dbg(ctx->dev, "Enable: pm usage count: %d\n", usage_count);
 153                 if (ret < 0) {
 154                         pm_runtime_put_sync(dev);
 155                         dev_err(ctx->dev, "Runtime get failed with err: %d\n", ret);
 156                         return ret;
 157                 }
 158                 if ((ctx->sst_state == SST_RESET) && (usage_count == 1)) {
 159                         ret = sst_load_fw(ctx);
 160                         if (ret) {
 161                                 dev_err(dev, "FW download fail %d\n", ret);
 162                                 sst_set_fw_state_locked(ctx, SST_RESET);
 163                                 ret = sst_pm_runtime_put(ctx);
 164                         }
 165                 }
 166         } else {
 167                 usage_count = GET_USAGE_COUNT(dev);
 168                 dev_dbg(ctx->dev, "Disable: pm usage count: %d\n", usage_count);
 169                 return sst_pm_runtime_put(ctx);
 170         }
 171         return ret;
 172 }
 173
 174 /*
 175  * sst_open_pcm_stream - Open PCM interface
 176  *
 177  * @str_param: parameters of pcm stream
 178  *
 179  * This function is called by MID sound card driver to open
 180  * a new pcm interface
 181  */
 182 static int sst_open_pcm_stream(struct device *dev,
 183                 struct snd_sst_params *str_param)
 184 {
 185         int retval;
 186         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 187
 188         if (!str_param)
 189                 return -EINVAL;
 190
 191         retval = sst_get_stream(ctx, str_param);
 192         if (retval > 0)
 193                 ctx->stream_cnt++;
 194         else
 195                 dev_err(ctx->dev, "sst_get_stream returned err %d\n", retval);
 196
 197         return retval;
 198 }
 199
 200 static int sst_cdev_open(struct device *dev,
 201                 struct snd_sst_params *str_params, struct sst_compress_cb *cb)
 202 {
 203         int str_id, retval;
 204         struct stream_info *stream;
 205         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 206
 207         retval = pm_runtime_get_sync(ctx->dev);
 208         if (retval < 0) {
 209                 pm_runtime_put_sync(ctx->dev);
 210                 return retval;
 211         }
 212
 213         str_id = sst_get_stream(ctx, str_params);
 214         if (str_id > 0) {
 215                 dev_dbg(dev, "stream allocated in sst_cdev_open %d\n", str_id);
 216                 stream = &ctx->streams[str_id];
 217                 stream->compr_cb = cb->compr_cb;
 218                 stream->compr_cb_param = cb->param;
 219                 stream->drain_notify = cb->drain_notify;
 220                 stream->drain_cb_param = cb->drain_cb_param;
 221         } else {
 222                 dev_err(dev, "stream encountered error during alloc %d\n", str_id);
 223                 str_id = -EINVAL;
 224                 sst_pm_runtime_put(ctx);
 225         }
 226         return str_id;
 227 }
 228
 229 static int sst_cdev_close(struct device *dev, unsigned int str_id)
 230 {
 231         int retval;
 232         struct stream_info *stream;
 233         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 234
 235         stream = get_stream_info(ctx, str_id);
 236         if (!stream) {
 237                 dev_err(dev, "stream info is NULL for str %d!!!\n", str_id);
 238                 return -EINVAL;
 239         }
 240
 241         if (stream->status == STREAM_RESET) {
 242                 dev_dbg(dev, "stream in reset state...\n");
 243                 stream->status = STREAM_UN_INIT;
 244
 245                 retval = 0;
 246                 goto put;
 247         }
 248
 249         retval = sst_free_stream(ctx, str_id);
 250 put:
 251         stream->compr_cb_param = NULL;
 252         stream->compr_cb = NULL;
 253
 254         if (retval)
 255                 dev_err(dev, "free stream returned err %d\n", retval);
 256
 257         dev_dbg(dev, "End\n");
 258         return retval;
 259
 260 }
 261
 262 static int sst_cdev_ack(struct device *dev, unsigned int str_id,
 263                 unsigned long bytes)
 264 {
 265         struct stream_info *stream;
 266         struct snd_sst_tstamp fw_tstamp = {0,};
 267         int offset;
 268         void __iomem *addr;
 269         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 270
 271         stream = get_stream_info(ctx, str_id);
 272         if (!stream)
 273                 return -EINVAL;
 274
 275         /* update bytes sent */
 276         stream->cumm_bytes += bytes;
 277         dev_dbg(dev, "bytes copied %d inc by %ld\n", stream->cumm_bytes, bytes);
 278
 279         memcpy_fromio(&fw_tstamp,
 280                 ((void *)(ctx->mailbox + ctx->tstamp)
 281                 +(str_id * sizeof(fw_tstamp))),
 282                 sizeof(fw_tstamp));
 283
 284         fw_tstamp.bytes_copied = stream->cumm_bytes;
 285         dev_dbg(dev, "bytes sent to fw %llu inc by %ld\n",
 286                         fw_tstamp.bytes_copied, bytes);
 287
 288         addr =  ((void *)(ctx->mailbox + ctx->tstamp)) +
 289                         (str_id * sizeof(fw_tstamp));
 290         offset =  offsetof(struct snd_sst_tstamp, bytes_copied);
 291         sst_shim_write(addr, offset, fw_tstamp.bytes_copied);
 292         return 0;
 293 }
 294
 295 static int sst_cdev_set_metadata(struct device *dev,
 296                 unsigned int str_id, struct snd_compr_metadata *metadata)
 297 {
 298         int retval = 0;
 299         struct stream_info *str_info;
 300         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 301
 302         dev_dbg(dev, "set metadata for stream %d\n", str_id);
 303
 304         str_info = get_stream_info(ctx, str_id);
 305         if (!str_info)
 306                 return -EINVAL;
 307
 308         dev_dbg(dev, "pipe id = %d\n", str_info->pipe_id);
 309         retval = sst_prepare_and_post_msg(ctx, str_info->task_id, IPC_CMD,
 310                         IPC_IA_SET_STREAM_PARAMS_MRFLD, str_info->pipe_id,
 311                         sizeof(*metadata), metadata, NULL,
 312                         true, true, true, false);
 313
 314         return retval;
 315 }
 316
 317 static int sst_cdev_stream_pause(struct device *dev, unsigned int str_id)
 318 {
 319         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 320
 321         return sst_pause_stream(ctx, str_id);
 322 }
 323
 324 static int sst_cdev_stream_pause_release(struct device *dev,
 325                 unsigned int str_id)
 326 {
 327         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 328
 329         return sst_resume_stream(ctx, str_id);
 330 }
 331
 332 static int sst_cdev_stream_start(struct device *dev, unsigned int str_id)
 333 {
 334         struct stream_info *str_info;
 335         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 336
 337         str_info = get_stream_info(ctx, str_id);
 338         if (!str_info)
 339                 return -EINVAL;
 340         str_info->prev = str_info->status;
 341         str_info->status = STREAM_RUNNING;
 342         return sst_start_stream(ctx, str_id);
 343 }
 344
 345 static int sst_cdev_stream_drop(struct device *dev, unsigned int str_id)
 346 {
 347         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 348
 349         return sst_drop_stream(ctx, str_id);
 350 }
 351
 352 static int sst_cdev_stream_drain(struct device *dev, unsigned int str_id)
 353 {
 354         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 355
 356         return sst_drain_stream(ctx, str_id, false);
 357 }
 358
 359 static int sst_cdev_stream_partial_drain(struct device *dev,
 360                 unsigned int str_id)
 361 {
 362         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 363
 364         return sst_drain_stream(ctx, str_id, true);
 365 }
 366
 367 static int sst_cdev_tstamp(struct device *dev, unsigned int str_id,
 368                 struct snd_compr_tstamp *tstamp)
 369 {
 370         struct snd_sst_tstamp fw_tstamp = {0,};
 371         struct stream_info *stream;
 372         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 373
 374         memcpy_fromio(&fw_tstamp,
 375                 ((void *)(ctx->mailbox + ctx->tstamp)
 376                 +(str_id * sizeof(fw_tstamp))),
 377                 sizeof(fw_tstamp));
 378
 379         stream = get_stream_info(ctx, str_id);
 380         if (!stream)
 381                 return -EINVAL;
 382         dev_dbg(dev, "rb_counter %llu in bytes\n", fw_tstamp.ring_buffer_counter);
 383
 384         tstamp->copied_total = fw_tstamp.ring_buffer_counter;
 385         tstamp->pcm_frames = fw_tstamp.frames_decoded;
 386         tstamp->pcm_io_frames = div_u64(fw_tstamp.hardware_counter,
 387                         (u64)stream->num_ch * SST_GET_BYTES_PER_SAMPLE(24));
 388         tstamp->sampling_rate = fw_tstamp.sampling_frequency;
 389
 390         dev_dbg(dev, "PCM  = %u\n", tstamp->pcm_io_frames);
 391         dev_dbg(dev, "Ptr Query on strid = %d  copied_total %d, decodec %d\n",
 392                 str_id, tstamp->copied_total, tstamp->pcm_frames);
 393         dev_dbg(dev, "rendered %d\n", tstamp->pcm_io_frames);
 394
 395         return 0;
 396 }
 397
 398 static int sst_cdev_caps(struct snd_compr_caps *caps)
 399 {
 400         caps->num_codecs = NUM_CODEC;
 401         caps->min_fragment_size = MIN_FRAGMENT_SIZE;  /* 50KB */
 402         caps->max_fragment_size = MAX_FRAGMENT_SIZE;  /* 1024KB */
 403         caps->min_fragments = MIN_FRAGMENT;
 404         caps->max_fragments = MAX_FRAGMENT;
 405         caps->codecs[0] = SND_AUDIOCODEC_MP3;
 406         caps->codecs[1] = SND_AUDIOCODEC_AAC;
 407         return 0;
 408 }
 409
 410 static struct snd_compr_codec_caps caps_mp3 = {
 411         .num_descriptors = 1,
 412         .descriptor[0].max_ch = 2,
 413         .descriptor[0].sample_rates[0] = 48000,
 414         .descriptor[0].sample_rates[1] = 44100,
 415         .descriptor[0].sample_rates[2] = 32000,
 416         .descriptor[0].sample_rates[3] = 16000,
 417         .descriptor[0].sample_rates[4] = 8000,
 418         .descriptor[0].num_sample_rates = 5,
 419         .descriptor[0].bit_rate[0] = 320,
 420         .descriptor[0].bit_rate[1] = 192,
 421         .descriptor[0].num_bitrates = 2,
 422         .descriptor[0].profiles = 0,
 423         .descriptor[0].modes = SND_AUDIOCHANMODE_MP3_STEREO,
 424         .descriptor[0].formats = 0,
 425 };
 426
 427 static struct snd_compr_codec_caps caps_aac = {
 428         .num_descriptors = 2,
 429         .descriptor[1].max_ch = 2,
 430         .descriptor[0].sample_rates[0] = 48000,
 431         .descriptor[0].sample_rates[1] = 44100,
 432         .descriptor[0].sample_rates[2] = 32000,
 433         .descriptor[0].sample_rates[3] = 16000,
 434         .descriptor[0].sample_rates[4] = 8000,
 435         .descriptor[0].num_sample_rates = 5,
 436         .descriptor[1].bit_rate[0] = 320,
 437         .descriptor[1].bit_rate[1] = 192,
 438         .descriptor[1].num_bitrates = 2,
 439         .descriptor[1].profiles = 0,
 440         .descriptor[1].modes = 0,
 441         .descriptor[1].formats =
 442                         (SND_AUDIOSTREAMFORMAT_MP4ADTS |
 443                                 SND_AUDIOSTREAMFORMAT_RAW),
 444 };
 445
 446 static int sst_cdev_codec_caps(struct snd_compr_codec_caps *codec)
 447 {
 448         if (codec->codec == SND_AUDIOCODEC_MP3)
 449                 *codec = caps_mp3;
 450         else if (codec->codec == SND_AUDIOCODEC_AAC)
 451                 *codec = caps_aac;
 452         else
 453                 return -EINVAL;
 454
 455         return 0;
 456 }
 457
 458 void sst_cdev_fragment_elapsed(struct intel_sst_drv *ctx, int str_id)
 459 {
 460         struct stream_info *stream;
 461
 462         dev_dbg(ctx->dev, "fragment elapsed from firmware for str_id %d\n",
 463                         str_id);
 464         stream = &ctx->streams[str_id];
 465         if (stream->compr_cb)
 466                 stream->compr_cb(stream->compr_cb_param);
 467 }
 468
 469 /*
 470  * sst_close_pcm_stream - Close PCM interface
 471  *
 472  * @str_id: stream id to be closed
 473  *
 474  * This function is called by MID sound card driver to close
 475  * an existing pcm interface
 476  */
 477 static int sst_close_pcm_stream(struct device *dev, unsigned int str_id)
 478 {
 479         struct stream_info *stream;
 480         int retval = 0;
 481         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 482
 483         stream = get_stream_info(ctx, str_id);
 484         if (!stream) {
 485                 dev_err(ctx->dev, "stream info is NULL for str %d!!!\n", str_id);
 486                 return -EINVAL;
 487         }
 488
 489         if (stream->status == STREAM_RESET) {
 490                 /* silently fail here as we have cleaned the stream earlier */
 491                 dev_dbg(ctx->dev, "stream in reset state...\n");
 492
 493                 retval = 0;
 494                 goto put;
 495         }
 496
 497         retval = free_stream_context(ctx, str_id);
 498 put:
 499         stream->pcm_substream = NULL;
 500         stream->status = STREAM_UN_INIT;
 501         stream->period_elapsed = NULL;
 502         ctx->stream_cnt--;
 503
 504         if (retval)
 505                 dev_err(ctx->dev, "free stream returned err %d\n", retval);
 506
 507         dev_dbg(ctx->dev, "Exit\n");
 508         return 0;
 509 }
 510
 511 static inline int sst_calc_tstamp(struct intel_sst_drv *ctx,
 512                 struct pcm_stream_info *info,
 513                 struct snd_pcm_substream *substream,
 514                 struct snd_sst_tstamp *fw_tstamp)
 515 {
 516         size_t delay_bytes, delay_frames;
 517         size_t buffer_sz;
 518         u32 pointer_bytes, pointer_samples;
 519
 520         dev_dbg(ctx->dev, "mrfld ring_buffer_counter %llu in bytes\n",
 521                         fw_tstamp->ring_buffer_counter);
 522         dev_dbg(ctx->dev, "mrfld hardware_counter %llu in bytes\n",
 523                          fw_tstamp->hardware_counter);
 524         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 525                 delay_bytes = (size_t) (fw_tstamp->ring_buffer_counter -
 526                                         fw_tstamp->hardware_counter);
 527         else
 528                 delay_bytes = (size_t) (fw_tstamp->hardware_counter -
 529                                         fw_tstamp->ring_buffer_counter);
 530         delay_frames = bytes_to_frames(substream->runtime, delay_bytes);
 531         buffer_sz = snd_pcm_lib_buffer_bytes(substream);
 532         div_u64_rem(fw_tstamp->ring_buffer_counter, buffer_sz, &pointer_bytes);
 533         pointer_samples = bytes_to_samples(substream->runtime, pointer_bytes);
 534
 535         dev_dbg(ctx->dev, "pcm delay %zu in bytes\n", delay_bytes);
 536
 537         info->buffer_ptr = pointer_samples / substream->runtime->channels;
 538
 539         info->pcm_delay = delay_frames;
 540         dev_dbg(ctx->dev, "buffer ptr %llu pcm_delay rep: %llu\n",
 541                         info->buffer_ptr, info->pcm_delay);
 542         return 0;
 543 }
 544
 545 static int sst_read_timestamp(struct device *dev, struct pcm_stream_info *info)
 546 {
 547         struct stream_info *stream;
 548         struct snd_pcm_substream *substream;
 549         struct snd_sst_tstamp fw_tstamp;
 550         unsigned int str_id;
 551         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 552
 553         str_id = info->str_id;
 554         stream = get_stream_info(ctx, str_id);
 555         if (!stream)
 556                 return -EINVAL;
 557
 558         if (!stream->pcm_substream)
 559                 return -EINVAL;
 560         substream = stream->pcm_substream;
 561
 562         memcpy_fromio(&fw_tstamp,
 563                 ((void *)(ctx->mailbox + ctx->tstamp)
 564                         + (str_id * sizeof(fw_tstamp))),
 565                 sizeof(fw_tstamp));
 566         return sst_calc_tstamp(ctx, info, substream, &fw_tstamp);
 567 }
 568
 569 static int sst_stream_start(struct device *dev, int str_id)
 570 {
 571         struct stream_info *str_info;
 572         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 573
 574         if (ctx->sst_state != SST_FW_RUNNING)
 575                 return 0;
 576         str_info = get_stream_info(ctx, str_id);
 577         if (!str_info)
 578                 return -EINVAL;
 579         str_info->prev = str_info->status;
 580         str_info->status = STREAM_RUNNING;
 581         sst_start_stream(ctx, str_id);
 582
 583         return 0;
 584 }
 585
 586 static int sst_stream_drop(struct device *dev, int str_id)
 587 {
 588         struct stream_info *str_info;
 589         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 590
 591         if (ctx->sst_state != SST_FW_RUNNING)
 592                 return 0;
 593
 594         str_info = get_stream_info(ctx, str_id);
 595         if (!str_info)
 596                 return -EINVAL;
 597         str_info->prev = STREAM_UN_INIT;
 598         str_info->status = STREAM_INIT;
 599         return sst_drop_stream(ctx, str_id);
 600 }
 601
 602 static int sst_stream_pause(struct device *dev, int str_id)
 603 {
 604         struct stream_info *str_info;
 605         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 606
 607         if (ctx->sst_state != SST_FW_RUNNING)
 608                 return 0;
 609
 610         str_info = get_stream_info(ctx, str_id);
 611         if (!str_info)
 612                 return -EINVAL;
 613
 614         return sst_pause_stream(ctx, str_id);
 615 }
 616
 617 static int sst_stream_resume(struct device *dev, int str_id)
 618 {
 619         struct stream_info *str_info;
 620         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 621
 622         if (ctx->sst_state != SST_FW_RUNNING)
 623                 return 0;
 624
 625         str_info = get_stream_info(ctx, str_id);
 626         if (!str_info)
 627                 return -EINVAL;
 628         return sst_resume_stream(ctx, str_id);
 629 }
 630
 631 static int sst_stream_init(struct device *dev, struct pcm_stream_info *str_info)
 632 {
 633         int str_id = 0;
 634         struct stream_info *stream;
 635         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 636
 637         str_id = str_info->str_id;
 638
 639         if (ctx->sst_state != SST_FW_RUNNING)
 640                 return 0;
 641
 642         stream = get_stream_info(ctx, str_id);
 643         if (!stream)
 644                 return -EINVAL;
 645
 646         dev_dbg(ctx->dev, "setting the period ptrs\n");
 647         stream->pcm_substream = str_info->arg;
 648         stream->period_elapsed = str_info->period_elapsed;
 649         stream->sfreq = str_info->sfreq;
 650         stream->prev = stream->status;
 651         stream->status = STREAM_INIT;
 652         dev_dbg(ctx->dev,
 653                 "pcm_substream %p, period_elapsed %p, sfreq %d, status %d\n",
 654                 stream->pcm_substream, stream->period_elapsed,
 655                 stream->sfreq, stream->status);
 656
 657         return 0;
 658 }
 659
 660 /*
 661  * sst_set_byte_stream - Set generic params
 662  *
 663  * @cmd: control cmd to be set
 664  * @arg: command argument
 665  *
 666  * This function is called by MID sound card driver to configure
 667  * SST runtime params.
 668  */
 669 static int sst_send_byte_stream(struct device *dev,
 670                 struct snd_sst_bytes_v2 *bytes)
 671 {
 672         int ret_val = 0;
 673         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
 674
 675         if (NULL == bytes)
 676                 return -EINVAL;
 677         ret_val = pm_runtime_get_sync(ctx->dev);
 678         if (ret_val < 0) {
 679                 pm_runtime_put_sync(ctx->dev);
 680                 return ret_val;
 681         }
 682
 683         ret_val = sst_send_byte_stream_mrfld(ctx, bytes);
 684         sst_pm_runtime_put(ctx);
 685
 686         return ret_val;
 687 }
 688
 689 static struct sst_ops pcm_ops = {
 690         .open = sst_open_pcm_stream,
 691         .stream_init = sst_stream_init,
 692         .stream_start = sst_stream_start,
 693         .stream_drop = sst_stream_drop,
 694         .stream_pause = sst_stream_pause,
 695         .stream_pause_release = sst_stream_resume,
 696         .stream_read_tstamp = sst_read_timestamp,
 697         .send_byte_stream = sst_send_byte_stream,
 698         .close = sst_close_pcm_stream,
 699         .power = sst_power_control,
 700 };
 701
 702 static struct compress_sst_ops compr_ops = {
 703         .open = sst_cdev_open,
 704         .close = sst_cdev_close,
 705         .stream_pause = sst_cdev_stream_pause,
 706         .stream_pause_release = sst_cdev_stream_pause_release,
 707         .stream_start = sst_cdev_stream_start,
 708         .stream_drop = sst_cdev_stream_drop,
 709         .stream_drain = sst_cdev_stream_drain,
 710         .stream_partial_drain = sst_cdev_stream_partial_drain,
 711         .tstamp = sst_cdev_tstamp,
 712         .ack = sst_cdev_ack,
 713         .get_caps = sst_cdev_caps,
 714         .get_codec_caps = sst_cdev_codec_caps,
 715         .set_metadata = sst_cdev_set_metadata,
 716         .power = sst_power_control,
 717 };
 718
 719 static struct sst_device sst_dsp_device = {
 720         .name = "Intel(R) SST LPE",
 721         .dev = NULL,
 722         .ops = &pcm_ops,
 723         .compr_ops = &compr_ops,
 724 };
 725
 726 /*
 727  * sst_register - function to register DSP
 728  *
 729  * This functions registers DSP with the platform driver
 730  */
 731 int sst_register(struct device *dev)
 732 {
 733         int ret_val;
 734
 735         sst_dsp_device.dev = dev;
 736         ret_val = sst_register_dsp(&sst_dsp_device);
 737         if (ret_val)
 738                 dev_err(dev, "Unable to register DSP with platform driver\n");
 739
 740         return ret_val;
 741 }
 742
 743 int sst_unregister(struct device *dev)
 744 {
 745         return sst_unregister_dsp(&sst_dsp_device);
 746 }