1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
51int 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
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
69int 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
84
85
86
87int 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
103
104
105
106int 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
122
123
124
125int 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
132 retval = ctx->ops->alloc_stream(ctx, str_param);
133 if (retval <= 0) {
134 return -EIO;
135 }
136
137 str_info = &ctx->streams[retval];
138 str_info->sfreq = sst_get_sfreq(str_param);
139
140 return retval;
141}
142
143static 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
176
177
178
179
180
181
182static 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
200static 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
229static 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);
250put:
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
262static 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
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
295static 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
317static 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
324static 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
332static 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
345static 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
352static 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
359static 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
367static 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
398static int sst_cdev_caps(struct snd_compr_caps *caps)
399{
400 caps->num_codecs = NUM_CODEC;
401 caps->min_fragment_size = MIN_FRAGMENT_SIZE;
402 caps->max_fragment_size = MAX_FRAGMENT_SIZE;
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
410static const 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
427static const 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
446static 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
458void 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
471
472
473
474
475
476
477static 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
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);
498put:
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
511static 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
545static 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
569static 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
586static 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
602static 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
617static 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
631static 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
662
663
664
665
666
667
668
669static 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
689static 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
702static 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
719static 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
728
729
730
731int 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
743int sst_unregister(struct device *dev)
744{
745 return sst_unregister_dsp(&sst_dsp_device);
746}
747
