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) { 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 retval = sst_free_stream(ctx, str_id); 242 stream->compr_cb_param = NULL; 243 stream->compr_cb = NULL; 244 245 if (retval) 246 dev_err(dev, "free stream returned err %d\n", retval); 247 248 dev_dbg(dev, "End\n"); 249 return retval; 250 } 251 252 static int sst_cdev_ack(struct device *dev, unsigned int str_id, 253 unsigned long bytes) 254 { 255 struct stream_info *stream; 256 struct snd_sst_tstamp fw_tstamp = {0,}; 257 int offset; 258 void __iomem *addr; 259 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 260 261 stream = get_stream_info(ctx, str_id); 262 if (!stream) 263 return -EINVAL; 264 265 /* update bytes sent */ 266 stream->cumm_bytes += bytes; 267 dev_dbg(dev, "bytes copied %d inc by %ld\n", stream->cumm_bytes, bytes); 268 269 addr = ((void __iomem *)(ctx->mailbox + ctx->tstamp)) + 270 (str_id * sizeof(fw_tstamp)); 271 272 memcpy_fromio(&fw_tstamp, addr, sizeof(fw_tstamp)); 273 274 fw_tstamp.bytes_copied = stream->cumm_bytes; 275 dev_dbg(dev, "bytes sent to fw %llu inc by %ld\n", 276 fw_tstamp.bytes_copied, bytes); 277 278 offset = offsetof(struct snd_sst_tstamp, bytes_copied); 279 sst_shim_write(addr, offset, fw_tstamp.bytes_copied); 280 return 0; 281 } 282 283 static int sst_cdev_set_metadata(struct device *dev, 284 unsigned int str_id, struct snd_compr_metadata *metadata) 285 { 286 int retval = 0; 287 struct stream_info *str_info; 288 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 289 290 dev_dbg(dev, "set metadata for stream %d\n", str_id); 291 292 str_info = get_stream_info(ctx, str_id); 293 if (!str_info) 294 return -EINVAL; 295 296 dev_dbg(dev, "pipe id = %d\n", str_info->pipe_id); 297 retval = sst_prepare_and_post_msg(ctx, str_info->task_id, IPC_CMD, 298 IPC_IA_SET_STREAM_PARAMS_MRFLD, str_info->pipe_id, 299 sizeof(*metadata), metadata, NULL, 300 true, true, true, false); 301 302 return retval; 303 } 304 305 static int sst_cdev_stream_pause(struct device *dev, unsigned int str_id) 306 { 307 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 308 309 return sst_pause_stream(ctx, str_id); 310 } 311 312 static int sst_cdev_stream_pause_release(struct device *dev, 313 unsigned int str_id) 314 { 315 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 316 317 return sst_resume_stream(ctx, str_id); 318 } 319 320 static int sst_cdev_stream_start(struct device *dev, unsigned int str_id) 321 { 322 struct stream_info *str_info; 323 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 324 325 str_info = get_stream_info(ctx, str_id); 326 if (!str_info) 327 return -EINVAL; 328 str_info->prev = str_info->status; 329 str_info->status = STREAM_RUNNING; 330 return sst_start_stream(ctx, str_id); 331 } 332 333 static int sst_cdev_stream_drop(struct device *dev, unsigned int str_id) 334 { 335 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 336 337 return sst_drop_stream(ctx, str_id); 338 } 339 340 static int sst_cdev_stream_drain(struct device *dev, unsigned int str_id) 341 { 342 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 343 344 return sst_drain_stream(ctx, str_id, false); 345 } 346 347 static int sst_cdev_stream_partial_drain(struct device *dev, 348 unsigned int str_id) 349 { 350 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 351 352 return sst_drain_stream(ctx, str_id, true); 353 } 354 355 static int sst_cdev_tstamp(struct device *dev, unsigned int str_id, 356 struct snd_compr_tstamp *tstamp) 357 { 358 struct snd_sst_tstamp fw_tstamp = {0,}; 359 struct stream_info *stream; 360 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 361 void __iomem *addr; 362 363 addr = (void __iomem *)(ctx->mailbox + ctx->tstamp) + 364 (str_id * sizeof(fw_tstamp)); 365 366 memcpy_fromio(&fw_tstamp, addr, sizeof(fw_tstamp)); 367 368 stream = get_stream_info(ctx, str_id); 369 if (!stream) 370 return -EINVAL; 371 dev_dbg(dev, "rb_counter %llu in bytes\n", fw_tstamp.ring_buffer_counter); 372 373 tstamp->copied_total = fw_tstamp.ring_buffer_counter; 374 tstamp->pcm_frames = fw_tstamp.frames_decoded; 375 tstamp->pcm_io_frames = div_u64(fw_tstamp.hardware_counter, 376 (u64)stream->num_ch * SST_GET_BYTES_PER_SAMPLE(24)); 377 tstamp->sampling_rate = fw_tstamp.sampling_frequency; 378 379 dev_dbg(dev, "PCM = %u\n", tstamp->pcm_io_frames); 380 dev_dbg(dev, "Ptr Query on strid = %d copied_total %d, decodec %d\n", 381 str_id, tstamp->copied_total, tstamp->pcm_frames); 382 dev_dbg(dev, "rendered %d\n", tstamp->pcm_io_frames); 383 384 return 0; 385 } 386 387 static int sst_cdev_caps(struct snd_compr_caps *caps) 388 { 389 caps->num_codecs = NUM_CODEC; 390 caps->min_fragment_size = MIN_FRAGMENT_SIZE; /* 50KB */ 391 caps->max_fragment_size = MAX_FRAGMENT_SIZE; /* 1024KB */ 392 caps->min_fragments = MIN_FRAGMENT; 393 caps->max_fragments = MAX_FRAGMENT; 394 caps->codecs[0] = SND_AUDIOCODEC_MP3; 395 caps->codecs[1] = SND_AUDIOCODEC_AAC; 396 return 0; 397 } 398 399 static const struct snd_compr_codec_caps caps_mp3 = { 400 .num_descriptors = 1, 401 .descriptor[0].max_ch = 2, 402 .descriptor[0].sample_rates[0] = 48000, 403 .descriptor[0].sample_rates[1] = 44100, 404 .descriptor[0].sample_rates[2] = 32000, 405 .descriptor[0].sample_rates[3] = 16000, 406 .descriptor[0].sample_rates[4] = 8000, 407 .descriptor[0].num_sample_rates = 5, 408 .descriptor[0].bit_rate[0] = 320, 409 .descriptor[0].bit_rate[1] = 192, 410 .descriptor[0].num_bitrates = 2, 411 .descriptor[0].profiles = 0, 412 .descriptor[0].modes = SND_AUDIOCHANMODE_MP3_STEREO, 413 .descriptor[0].formats = 0, 414 }; 415 416 static const struct snd_compr_codec_caps caps_aac = { 417 .num_descriptors = 2, 418 .descriptor[1].max_ch = 2, 419 .descriptor[0].sample_rates[0] = 48000, 420 .descriptor[0].sample_rates[1] = 44100, 421 .descriptor[0].sample_rates[2] = 32000, 422 .descriptor[0].sample_rates[3] = 16000, 423 .descriptor[0].sample_rates[4] = 8000, 424 .descriptor[0].num_sample_rates = 5, 425 .descriptor[1].bit_rate[0] = 320, 426 .descriptor[1].bit_rate[1] = 192, 427 .descriptor[1].num_bitrates = 2, 428 .descriptor[1].profiles = 0, 429 .descriptor[1].modes = 0, 430 .descriptor[1].formats = 431 (SND_AUDIOSTREAMFORMAT_MP4ADTS | 432 SND_AUDIOSTREAMFORMAT_RAW), 433 }; 434 435 static int sst_cdev_codec_caps(struct snd_compr_codec_caps *codec) 436 { 437 if (codec->codec == SND_AUDIOCODEC_MP3) 438 *codec = caps_mp3; 439 else if (codec->codec == SND_AUDIOCODEC_AAC) 440 *codec = caps_aac; 441 else 442 return -EINVAL; 443 444 return 0; 445 } 446 447 void sst_cdev_fragment_elapsed(struct intel_sst_drv *ctx, int str_id) 448 { 449 struct stream_info *stream; 450 451 dev_dbg(ctx->dev, "fragment elapsed from firmware for str_id %d\n", 452 str_id); 453 stream = &ctx->streams[str_id]; 454 if (stream->compr_cb) 455 stream->compr_cb(stream->compr_cb_param); 456 } 457 458 /* 459 * sst_close_pcm_stream - Close PCM interface 460 * 461 * @str_id: stream id to be closed 462 * 463 * This function is called by MID sound card driver to close 464 * an existing pcm interface 465 */ 466 static int sst_close_pcm_stream(struct device *dev, unsigned int str_id) 467 { 468 struct stream_info *stream; 469 int retval = 0; 470 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 471 472 stream = get_stream_info(ctx, str_id); 473 if (!stream) { 474 dev_err(ctx->dev, "stream info is NULL for str %d!!!\n", str_id); 475 return -EINVAL; 476 } 477 478 retval = free_stream_context(ctx, str_id); 479 stream->pcm_substream = NULL; 480 stream->status = STREAM_UN_INIT; 481 stream->period_elapsed = NULL; 482 ctx->stream_cnt--; 483 484 if (retval) 485 dev_err(ctx->dev, "free stream returned err %d\n", retval); 486 487 dev_dbg(ctx->dev, "Exit\n"); 488 return 0; 489 } 490 491 static inline int sst_calc_tstamp(struct intel_sst_drv *ctx, 492 struct pcm_stream_info *info, 493 struct snd_pcm_substream *substream, 494 struct snd_sst_tstamp *fw_tstamp) 495 { 496 size_t delay_bytes, delay_frames; 497 size_t buffer_sz; 498 u32 pointer_bytes, pointer_samples; 499 500 dev_dbg(ctx->dev, "mrfld ring_buffer_counter %llu in bytes\n", 501 fw_tstamp->ring_buffer_counter); 502 dev_dbg(ctx->dev, "mrfld hardware_counter %llu in bytes\n", 503 fw_tstamp->hardware_counter); 504 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 505 delay_bytes = (size_t) (fw_tstamp->ring_buffer_counter - 506 fw_tstamp->hardware_counter); 507 else 508 delay_bytes = (size_t) (fw_tstamp->hardware_counter - 509 fw_tstamp->ring_buffer_counter); 510 delay_frames = bytes_to_frames(substream->runtime, delay_bytes); 511 buffer_sz = snd_pcm_lib_buffer_bytes(substream); 512 div_u64_rem(fw_tstamp->ring_buffer_counter, buffer_sz, &pointer_bytes); 513 pointer_samples = bytes_to_samples(substream->runtime, pointer_bytes); 514 515 dev_dbg(ctx->dev, "pcm delay %zu in bytes\n", delay_bytes); 516 517 info->buffer_ptr = pointer_samples / substream->runtime->channels; 518 519 info->pcm_delay = delay_frames; 520 dev_dbg(ctx->dev, "buffer ptr %llu pcm_delay rep: %llu\n", 521 info->buffer_ptr, info->pcm_delay); 522 return 0; 523 } 524 525 static int sst_read_timestamp(struct device *dev, struct pcm_stream_info *info) 526 { 527 struct stream_info *stream; 528 struct snd_pcm_substream *substream; 529 struct snd_sst_tstamp fw_tstamp; 530 unsigned int str_id; 531 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 532 void __iomem *addr; 533 534 str_id = info->str_id; 535 stream = get_stream_info(ctx, str_id); 536 if (!stream) 537 return -EINVAL; 538 539 if (!stream->pcm_substream) 540 return -EINVAL; 541 substream = stream->pcm_substream; 542 543 addr = (void __iomem *)(ctx->mailbox + ctx->tstamp) + 544 (str_id * sizeof(fw_tstamp)); 545 546 memcpy_fromio(&fw_tstamp, addr, sizeof(fw_tstamp)); 547 548 return sst_calc_tstamp(ctx, info, substream, &fw_tstamp); 549 } 550 551 static int sst_stream_start(struct device *dev, int str_id) 552 { 553 struct stream_info *str_info; 554 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 555 556 if (ctx->sst_state != SST_FW_RUNNING) 557 return 0; 558 str_info = get_stream_info(ctx, str_id); 559 if (!str_info) 560 return -EINVAL; 561 str_info->prev = str_info->status; 562 str_info->status = STREAM_RUNNING; 563 sst_start_stream(ctx, str_id); 564 565 return 0; 566 } 567 568 static int sst_stream_drop(struct device *dev, int str_id) 569 { 570 struct stream_info *str_info; 571 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 572 573 if (ctx->sst_state != SST_FW_RUNNING) 574 return 0; 575 576 str_info = get_stream_info(ctx, str_id); 577 if (!str_info) 578 return -EINVAL; 579 str_info->prev = STREAM_UN_INIT; 580 str_info->status = STREAM_INIT; 581 return sst_drop_stream(ctx, str_id); 582 } 583 584 static int sst_stream_pause(struct device *dev, int str_id) 585 { 586 struct stream_info *str_info; 587 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 588 589 if (ctx->sst_state != SST_FW_RUNNING) 590 return 0; 591 592 str_info = get_stream_info(ctx, str_id); 593 if (!str_info) 594 return -EINVAL; 595 596 return sst_pause_stream(ctx, str_id); 597 } 598 599 static int sst_stream_resume(struct device *dev, int str_id) 600 { 601 struct stream_info *str_info; 602 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 603 604 if (ctx->sst_state != SST_FW_RUNNING) 605 return 0; 606 607 str_info = get_stream_info(ctx, str_id); 608 if (!str_info) 609 return -EINVAL; 610 return sst_resume_stream(ctx, str_id); 611 } 612 613 static int sst_stream_init(struct device *dev, struct pcm_stream_info *str_info) 614 { 615 int str_id = 0; 616 struct stream_info *stream; 617 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 618 619 str_id = str_info->str_id; 620 621 if (ctx->sst_state != SST_FW_RUNNING) 622 return 0; 623 624 stream = get_stream_info(ctx, str_id); 625 if (!stream) 626 return -EINVAL; 627 628 dev_dbg(ctx->dev, "setting the period ptrs\n"); 629 stream->pcm_substream = str_info->arg; 630 stream->period_elapsed = str_info->period_elapsed; 631 stream->sfreq = str_info->sfreq; 632 stream->prev = stream->status; 633 stream->status = STREAM_INIT; 634 dev_dbg(ctx->dev, 635 "pcm_substream %p, period_elapsed %p, sfreq %d, status %d\n", 636 stream->pcm_substream, stream->period_elapsed, 637 stream->sfreq, stream->status); 638 639 return 0; 640 } 641 642 /* 643 * sst_set_byte_stream - Set generic params 644 * 645 * @cmd: control cmd to be set 646 * @arg: command argument 647 * 648 * This function is called by MID sound card driver to configure 649 * SST runtime params. 650 */ 651 static int sst_send_byte_stream(struct device *dev, 652 struct snd_sst_bytes_v2 *bytes) 653 { 654 int ret_val = 0; 655 struct intel_sst_drv *ctx = dev_get_drvdata(dev); 656 657 if (NULL == bytes) 658 return -EINVAL; 659 ret_val = pm_runtime_get_sync(ctx->dev); 660 if (ret_val < 0) { 661 pm_runtime_put_sync(ctx->dev); 662 return ret_val; 663 } 664 665 ret_val = sst_send_byte_stream_mrfld(ctx, bytes); 666 sst_pm_runtime_put(ctx); 667 668 return ret_val; 669 } 670 671 static struct sst_ops pcm_ops = { 672 .open = sst_open_pcm_stream, 673 .stream_init = sst_stream_init, 674 .stream_start = sst_stream_start, 675 .stream_drop = sst_stream_drop, 676 .stream_pause = sst_stream_pause, 677 .stream_pause_release = sst_stream_resume, 678 .stream_read_tstamp = sst_read_timestamp, 679 .send_byte_stream = sst_send_byte_stream, 680 .close = sst_close_pcm_stream, 681 .power = sst_power_control, 682 }; 683 684 static struct compress_sst_ops compr_ops = { 685 .open = sst_cdev_open, 686 .close = sst_cdev_close, 687 .stream_pause = sst_cdev_stream_pause, 688 .stream_pause_release = sst_cdev_stream_pause_release, 689 .stream_start = sst_cdev_stream_start, 690 .stream_drop = sst_cdev_stream_drop, 691 .stream_drain = sst_cdev_stream_drain, 692 .stream_partial_drain = sst_cdev_stream_partial_drain, 693 .tstamp = sst_cdev_tstamp, 694 .ack = sst_cdev_ack, 695 .get_caps = sst_cdev_caps, 696 .get_codec_caps = sst_cdev_codec_caps, 697 .set_metadata = sst_cdev_set_metadata, 698 .power = sst_power_control, 699 }; 700 701 static struct sst_device sst_dsp_device = { 702 .name = "Intel(R) SST LPE", 703 .dev = NULL, 704 .ops = &pcm_ops, 705 .compr_ops = &compr_ops, 706 }; 707 708 /* 709 * sst_register - function to register DSP 710 * 711 * This functions registers DSP with the platform driver 712 */ 713 int sst_register(struct device *dev) 714 { 715 int ret_val; 716 717 sst_dsp_device.dev = dev; 718 ret_val = sst_register_dsp(&sst_dsp_device); 719 if (ret_val) 720 dev_err(dev, "Unable to register DSP with platform driver\n"); 721 722 return ret_val; 723 } 724 725 int sst_unregister(struct device *dev) 726 { 727 return sst_unregister_dsp(&sst_dsp_device); 728 } 729