1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2011-2017, The Linux Foundation. All rights reserved.
3 // Copyright (c) 2018, Linaro Limited
5 #include <linux/mutex.h>
6 #include <linux/wait.h>
7 #include <linux/module.h>
8 #include <linux/soc/qcom/apr.h>
9 #include <linux/device.h>
10 #include <linux/of_platform.h>
11 #include <linux/spinlock.h>
12 #include <linux/kref.h>
14 #include <uapi/sound/asound.h>
15 #include <uapi/sound/compress_params.h>
16 #include <linux/delay.h>
17 #include <linux/slab.h>
21 #include "q6dsp-errno.h"
22 #include "q6dsp-common.h"
24 #define ASM_STREAM_CMD_CLOSE 0x00010BCD
25 #define ASM_STREAM_CMD_FLUSH 0x00010BCE
26 #define ASM_SESSION_CMD_PAUSE 0x00010BD3
27 #define ASM_DATA_CMD_EOS 0x00010BDB
28 #define ASM_DATA_EVENT_RENDERED_EOS 0x00010C1C
29 #define ASM_NULL_POPP_TOPOLOGY 0x00010C68
30 #define ASM_STREAM_CMD_FLUSH_READBUFS 0x00010C09
31 #define ASM_STREAM_CMD_SET_ENCDEC_PARAM 0x00010C10
32 #define ASM_STREAM_POSTPROC_TOPO_ID_NONE 0x00010C68
33 #define ASM_CMD_SHARED_MEM_MAP_REGIONS 0x00010D92
34 #define ASM_CMDRSP_SHARED_MEM_MAP_REGIONS 0x00010D93
35 #define ASM_CMD_SHARED_MEM_UNMAP_REGIONS 0x00010D94
36 #define ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2 0x00010D98
37 #define ASM_DATA_EVENT_WRITE_DONE_V2 0x00010D99
38 #define ASM_PARAM_ID_ENCDEC_ENC_CFG_BLK_V2 0x00010DA3
39 #define ASM_SESSION_CMD_RUN_V2 0x00010DAA
40 #define ASM_MEDIA_FMT_MULTI_CHANNEL_PCM_V2 0x00010DA5
41 #define ASM_MEDIA_FMT_MP3 0x00010BE9
42 #define ASM_MEDIA_FMT_FLAC 0x00010C16
43 #define ASM_MEDIA_FMT_WMA_V9 0x00010DA8
44 #define ASM_MEDIA_FMT_WMA_V10 0x00010DA7
45 #define ASM_DATA_CMD_WRITE_V2 0x00010DAB
46 #define ASM_DATA_CMD_READ_V2 0x00010DAC
47 #define ASM_SESSION_CMD_SUSPEND 0x00010DEC
48 #define ASM_STREAM_CMD_OPEN_WRITE_V3 0x00010DB3
49 #define ASM_STREAM_CMD_OPEN_READ_V3 0x00010DB4
50 #define ASM_DATA_EVENT_READ_DONE_V2 0x00010D9A
51 #define ASM_STREAM_CMD_OPEN_READWRITE_V2 0x00010D8D
52 #define ASM_MEDIA_FMT_ALAC 0x00012f31
53 #define ASM_MEDIA_FMT_APE 0x00012f32
56 #define ASM_LEGACY_STREAM_SESSION 0
57 /* Bit shift for the stream_perf_mode subfield. */
58 #define ASM_SHIFT_STREAM_PERF_MODE_FLAG_IN_OPEN_READ 29
59 #define ASM_END_POINT_DEVICE_MATRIX 0
60 #define ASM_DEFAULT_APP_TYPE 0
61 #define ASM_SYNC_IO_MODE 0x0001
62 #define ASM_ASYNC_IO_MODE 0x0002
63 #define ASM_TUN_READ_IO_MODE 0x0004 /* tunnel read write mode */
64 #define ASM_TUN_WRITE_IO_MODE 0x0008 /* tunnel read write mode */
65 #define ASM_SHIFT_GAPLESS_MODE_FLAG 31
66 #define ADSP_MEMORY_MAP_SHMEM8_4K_POOL 3
68 struct avs_cmd_shared_mem_map_regions {
74 struct avs_shared_map_region_payload {
80 struct avs_cmd_shared_mem_unmap_regions {
84 struct asm_data_cmd_media_fmt_update_v2 {
88 struct asm_multi_channel_pcm_fmt_blk_v2 {
89 struct asm_data_cmd_media_fmt_update_v2 fmt_blk;
95 u8 channel_mapping[PCM_MAX_NUM_CHANNEL];
98 struct asm_flac_fmt_blk_v2 {
99 struct asm_data_cmd_media_fmt_update_v2 fmt_blk;
100 u16 is_stream_info_present;
112 struct asm_wmastdv9_fmt_blk_v2 {
113 struct asm_data_cmd_media_fmt_update_v2 fmt_blk;
125 struct asm_wmaprov10_fmt_blk_v2 {
126 struct asm_data_cmd_media_fmt_update_v2 fmt_blk;
135 u16 advanced_enc_options1;
136 u32 advanced_enc_options2;
139 struct asm_alac_fmt_blk_v2 {
140 struct asm_data_cmd_media_fmt_update_v2 fmt_blk;
142 u8 compatible_version;
152 u32 channel_layout_tag;
155 struct asm_ape_fmt_blk_v2 {
156 struct asm_data_cmd_media_fmt_update_v2 fmt_blk;
157 u16 compatible_version;
158 u16 compression_level;
160 u32 blocks_per_frame;
161 u32 final_frame_blocks;
166 u32 seek_table_present;
169 struct asm_stream_cmd_set_encdec_param {
174 struct asm_enc_cfg_blk_param_v2 {
176 u32 enc_cfg_blk_size;
179 struct asm_multi_channel_pcm_enc_cfg_v2 {
180 struct asm_stream_cmd_set_encdec_param encdec;
181 struct asm_enc_cfg_blk_param_v2 encblk;
182 uint16_t num_channels;
183 uint16_t bits_per_sample;
184 uint32_t sample_rate;
187 uint8_t channel_mapping[8];
190 struct asm_data_cmd_read_v2 {
198 struct asm_data_cmd_read_v2_done {
204 struct asm_stream_cmd_open_read_v3 {
213 struct asm_data_cmd_write_v2 {
224 struct asm_stream_cmd_open_write_v3 {
226 uint16_t sink_endpointype;
227 uint16_t bits_per_sample;
228 uint32_t postprocopo_id;
232 struct asm_session_cmd_run_v2 {
238 struct audio_buffer {
240 uint32_t size; /* size of buffer */
243 struct audio_port_data {
244 struct audio_buffer *buf;
245 uint32_t num_periods;
247 uint32_t mem_map_handle;
251 struct apr_device *adev;
253 struct q6core_svc_api_info ainfo;
254 wait_queue_head_t mem_wait;
256 struct audio_client *session[MAX_SESSIONS + 1];
259 struct audio_client {
264 struct apr_device *adev;
265 struct mutex cmd_lock;
267 struct kref refcount;
268 /* idx:1 out port, 0: in port */
269 struct audio_port_data port[2];
270 wait_queue_head_t cmd_wait;
271 struct aprv2_ibasic_rsp_result_t result;
278 static inline void q6asm_add_hdr(struct audio_client *ac, struct apr_hdr *hdr,
279 uint32_t pkt_size, bool cmd_flg,
282 hdr->hdr_field = APR_SEQ_CMD_HDR_FIELD;
283 hdr->src_port = ((ac->session << 8) & 0xFF00) | (stream_id);
284 hdr->dest_port = ((ac->session << 8) & 0xFF00) | (stream_id);
285 hdr->pkt_size = pkt_size;
287 hdr->token = ac->session;
290 static int q6asm_apr_send_session_pkt(struct q6asm *a, struct audio_client *ac,
291 struct apr_pkt *pkt, uint32_t rsp_opcode)
293 struct apr_hdr *hdr = &pkt->hdr;
296 mutex_lock(&ac->cmd_lock);
297 ac->result.opcode = 0;
298 ac->result.status = 0;
299 rc = apr_send_pkt(a->adev, pkt);
304 rc = wait_event_timeout(a->mem_wait,
305 (ac->result.opcode == hdr->opcode) ||
306 (ac->result.opcode == rsp_opcode),
309 rc = wait_event_timeout(a->mem_wait,
310 (ac->result.opcode == hdr->opcode),
314 dev_err(a->dev, "CMD %x timeout\n", hdr->opcode);
316 } else if (ac->result.status > 0) {
317 dev_err(a->dev, "DSP returned error[%x]\n",
323 mutex_unlock(&ac->cmd_lock);
327 static int __q6asm_memory_unmap(struct audio_client *ac,
328 phys_addr_t buf_add, int dir)
330 struct avs_cmd_shared_mem_unmap_regions *mem_unmap;
331 struct q6asm *a = dev_get_drvdata(ac->dev->parent);
336 if (ac->port[dir].mem_map_handle == 0) {
337 dev_err(ac->dev, "invalid mem handle\n");
341 pkt_size = APR_HDR_SIZE + sizeof(*mem_unmap);
342 p = kzalloc(pkt_size, GFP_KERNEL);
347 mem_unmap = p + APR_HDR_SIZE;
349 pkt->hdr.hdr_field = APR_SEQ_CMD_HDR_FIELD;
350 pkt->hdr.src_port = 0;
351 pkt->hdr.dest_port = 0;
352 pkt->hdr.pkt_size = pkt_size;
353 pkt->hdr.token = ((ac->session << 8) | dir);
355 pkt->hdr.opcode = ASM_CMD_SHARED_MEM_UNMAP_REGIONS;
356 mem_unmap->mem_map_handle = ac->port[dir].mem_map_handle;
358 rc = q6asm_apr_send_session_pkt(a, ac, pkt, 0);
364 ac->port[dir].mem_map_handle = 0;
371 static void q6asm_audio_client_free_buf(struct audio_client *ac,
372 struct audio_port_data *port)
376 spin_lock_irqsave(&ac->lock, flags);
377 port->num_periods = 0;
380 spin_unlock_irqrestore(&ac->lock, flags);
384 * q6asm_unmap_memory_regions() - unmap memory regions in the dsp.
386 * @dir: direction of audio stream
387 * @ac: audio client instanace
389 * Return: Will be an negative value on failure or zero on success
391 int q6asm_unmap_memory_regions(unsigned int dir, struct audio_client *ac)
393 struct audio_port_data *port;
397 port = &ac->port[dir];
403 cnt = port->num_periods - 1;
405 rc = __q6asm_memory_unmap(ac, port->buf[dir].phys, dir);
407 dev_err(ac->dev, "%s: Memory_unmap_regions failed %d\n",
413 q6asm_audio_client_free_buf(ac, port);
418 EXPORT_SYMBOL_GPL(q6asm_unmap_memory_regions);
420 static int __q6asm_memory_map_regions(struct audio_client *ac, int dir,
421 size_t period_sz, unsigned int periods,
424 struct avs_cmd_shared_mem_map_regions *cmd = NULL;
425 struct avs_shared_map_region_payload *mregions = NULL;
426 struct q6asm *a = dev_get_drvdata(ac->dev->parent);
427 struct audio_port_data *port = NULL;
428 struct audio_buffer *ab = NULL;
432 uint32_t num_regions, buf_sz;
437 buf_sz = period_sz * periods;
440 num_regions = periods;
443 /* DSP expects size should be aligned to 4K */
444 buf_sz = ALIGN(buf_sz, 4096);
446 pkt_size = APR_HDR_SIZE + sizeof(*cmd) +
447 (sizeof(*mregions) * num_regions);
449 p = kzalloc(pkt_size, GFP_KERNEL);
454 cmd = p + APR_HDR_SIZE;
455 mregions = p + APR_HDR_SIZE + sizeof(*cmd);
457 pkt->hdr.hdr_field = APR_SEQ_CMD_HDR_FIELD;
458 pkt->hdr.src_port = 0;
459 pkt->hdr.dest_port = 0;
460 pkt->hdr.pkt_size = pkt_size;
461 pkt->hdr.token = ((ac->session << 8) | dir);
462 pkt->hdr.opcode = ASM_CMD_SHARED_MEM_MAP_REGIONS;
464 cmd->mem_pool_id = ADSP_MEMORY_MAP_SHMEM8_4K_POOL;
465 cmd->num_regions = num_regions;
466 cmd->property_flag = 0x00;
468 spin_lock_irqsave(&ac->lock, flags);
469 port = &ac->port[dir];
471 for (i = 0; i < num_regions; i++) {
473 mregions->shm_addr_lsw = lower_32_bits(ab->phys);
474 mregions->shm_addr_msw = upper_32_bits(ab->phys);
475 mregions->mem_size_bytes = buf_sz;
478 spin_unlock_irqrestore(&ac->lock, flags);
480 rc = q6asm_apr_send_session_pkt(a, ac, pkt,
481 ASM_CMDRSP_SHARED_MEM_MAP_REGIONS);
489 * q6asm_map_memory_regions() - map memory regions in the dsp.
491 * @dir: direction of audio stream
492 * @ac: audio client instanace
493 * @phys: physcial address that needs mapping.
494 * @period_sz: audio period size
495 * @periods: number of periods
497 * Return: Will be an negative value on failure or zero on success
499 int q6asm_map_memory_regions(unsigned int dir, struct audio_client *ac,
501 size_t period_sz, unsigned int periods)
503 struct audio_buffer *buf;
508 spin_lock_irqsave(&ac->lock, flags);
509 if (ac->port[dir].buf) {
510 dev_err(ac->dev, "Buffer already allocated\n");
511 spin_unlock_irqrestore(&ac->lock, flags);
515 buf = kzalloc(((sizeof(struct audio_buffer)) * periods), GFP_ATOMIC);
517 spin_unlock_irqrestore(&ac->lock, flags);
522 ac->port[dir].buf = buf;
525 buf[0].size = period_sz;
527 for (cnt = 1; cnt < periods; cnt++) {
529 buf[cnt].phys = buf[0].phys + (cnt * period_sz);
530 buf[cnt].size = period_sz;
533 ac->port[dir].num_periods = periods;
535 spin_unlock_irqrestore(&ac->lock, flags);
537 rc = __q6asm_memory_map_regions(ac, dir, period_sz, periods, 1);
539 dev_err(ac->dev, "Memory_map_regions failed\n");
540 q6asm_audio_client_free_buf(ac, &ac->port[dir]);
545 EXPORT_SYMBOL_GPL(q6asm_map_memory_regions);
547 static void q6asm_audio_client_release(struct kref *ref)
549 struct audio_client *ac;
553 ac = container_of(ref, struct audio_client, refcount);
556 spin_lock_irqsave(&a->slock, flags);
557 a->session[ac->session] = NULL;
558 spin_unlock_irqrestore(&a->slock, flags);
564 * q6asm_audio_client_free() - Freee allocated audio client
566 * @ac: audio client to free
568 void q6asm_audio_client_free(struct audio_client *ac)
570 kref_put(&ac->refcount, q6asm_audio_client_release);
572 EXPORT_SYMBOL_GPL(q6asm_audio_client_free);
574 static struct audio_client *q6asm_get_audio_client(struct q6asm *a,
577 struct audio_client *ac = NULL;
580 spin_lock_irqsave(&a->slock, flags);
581 if ((session_id <= 0) || (session_id > MAX_SESSIONS)) {
582 dev_err(a->dev, "invalid session: %d\n", session_id);
586 /* check for valid session */
587 if (!a->session[session_id])
589 else if (a->session[session_id]->session != session_id)
592 ac = a->session[session_id];
593 kref_get(&ac->refcount);
595 spin_unlock_irqrestore(&a->slock, flags);
599 static int32_t q6asm_stream_callback(struct apr_device *adev,
600 struct apr_resp_pkt *data,
603 struct q6asm *q6asm = dev_get_drvdata(&adev->dev);
604 struct aprv2_ibasic_rsp_result_t *result;
605 struct apr_hdr *hdr = &data->hdr;
606 struct audio_port_data *port;
607 struct audio_client *ac;
608 uint32_t client_event = 0;
611 ac = q6asm_get_audio_client(q6asm, session_id);
612 if (!ac)/* Audio client might already be freed by now */
615 result = data->payload;
617 switch (hdr->opcode) {
618 case APR_BASIC_RSP_RESULT:
619 switch (result->opcode) {
620 case ASM_SESSION_CMD_PAUSE:
621 client_event = ASM_CLIENT_EVENT_CMD_PAUSE_DONE;
623 case ASM_SESSION_CMD_SUSPEND:
624 client_event = ASM_CLIENT_EVENT_CMD_SUSPEND_DONE;
626 case ASM_STREAM_CMD_FLUSH:
627 client_event = ASM_CLIENT_EVENT_CMD_FLUSH_DONE;
629 case ASM_SESSION_CMD_RUN_V2:
630 client_event = ASM_CLIENT_EVENT_CMD_RUN_DONE;
632 case ASM_STREAM_CMD_CLOSE:
633 client_event = ASM_CLIENT_EVENT_CMD_CLOSE_DONE;
635 case ASM_STREAM_CMD_FLUSH_READBUFS:
636 client_event = ASM_CLIENT_EVENT_CMD_OUT_FLUSH_DONE;
638 case ASM_STREAM_CMD_OPEN_WRITE_V3:
639 case ASM_STREAM_CMD_OPEN_READ_V3:
640 case ASM_STREAM_CMD_OPEN_READWRITE_V2:
641 case ASM_STREAM_CMD_SET_ENCDEC_PARAM:
642 case ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2:
643 if (result->status != 0) {
645 "cmd = 0x%x returned error = 0x%x\n",
646 result->opcode, result->status);
647 ac->result = *result;
648 wake_up(&ac->cmd_wait);
654 dev_err(ac->dev, "command[0x%x] not expecting rsp\n",
659 ac->result = *result;
660 wake_up(&ac->cmd_wait);
663 ac->cb(client_event, hdr->token,
664 data->payload, ac->priv);
669 case ASM_DATA_EVENT_WRITE_DONE_V2:
670 client_event = ASM_CLIENT_EVENT_DATA_WRITE_DONE;
671 if (ac->io_mode & ASM_SYNC_IO_MODE) {
675 spin_lock_irqsave(&ac->lock, flags);
677 port = &ac->port[SNDRV_PCM_STREAM_PLAYBACK];
680 spin_unlock_irqrestore(&ac->lock, flags);
685 phys = port->buf[hdr->token].phys;
687 if (lower_32_bits(phys) != result->opcode ||
688 upper_32_bits(phys) != result->status) {
689 dev_err(ac->dev, "Expected addr %pa\n",
690 &port->buf[hdr->token].phys);
691 spin_unlock_irqrestore(&ac->lock, flags);
695 spin_unlock_irqrestore(&ac->lock, flags);
698 case ASM_DATA_EVENT_READ_DONE_V2:
699 client_event = ASM_CLIENT_EVENT_DATA_READ_DONE;
700 if (ac->io_mode & ASM_SYNC_IO_MODE) {
701 struct asm_data_cmd_read_v2_done *done = data->payload;
705 spin_lock_irqsave(&ac->lock, flags);
706 port = &ac->port[SNDRV_PCM_STREAM_CAPTURE];
708 spin_unlock_irqrestore(&ac->lock, flags);
713 phys = port->buf[hdr->token].phys;
715 if (upper_32_bits(phys) != done->buf_addr_msw ||
716 lower_32_bits(phys) != done->buf_addr_lsw) {
717 dev_err(ac->dev, "Expected addr %pa %08x-%08x\n",
718 &port->buf[hdr->token].phys,
721 spin_unlock_irqrestore(&ac->lock, flags);
725 spin_unlock_irqrestore(&ac->lock, flags);
729 case ASM_DATA_EVENT_RENDERED_EOS:
730 client_event = ASM_CLIENT_EVENT_CMD_EOS_DONE;
735 ac->cb(client_event, hdr->token, data->payload, ac->priv);
738 kref_put(&ac->refcount, q6asm_audio_client_release);
742 static int q6asm_srvc_callback(struct apr_device *adev,
743 struct apr_resp_pkt *data)
745 struct q6asm *q6asm = dev_get_drvdata(&adev->dev);
746 struct aprv2_ibasic_rsp_result_t *result;
747 struct audio_port_data *port;
748 struct audio_client *ac = NULL;
749 struct apr_hdr *hdr = &data->hdr;
755 session_id = (hdr->dest_port >> 8) & 0xFF;
757 return q6asm_stream_callback(adev, data, session_id);
759 sid = (hdr->token >> 8) & 0x0F;
760 ac = q6asm_get_audio_client(q6asm, sid);
762 dev_err(&adev->dev, "Audio Client not active\n");
766 a = dev_get_drvdata(ac->dev->parent);
767 dir = (hdr->token & 0x0F);
768 port = &ac->port[dir];
769 result = data->payload;
771 switch (hdr->opcode) {
772 case APR_BASIC_RSP_RESULT:
773 switch (result->opcode) {
774 case ASM_CMD_SHARED_MEM_MAP_REGIONS:
775 case ASM_CMD_SHARED_MEM_UNMAP_REGIONS:
776 ac->result = *result;
777 wake_up(&a->mem_wait);
780 dev_err(&adev->dev, "command[0x%x] not expecting rsp\n",
785 case ASM_CMDRSP_SHARED_MEM_MAP_REGIONS:
786 ac->result.status = 0;
787 ac->result.opcode = hdr->opcode;
788 port->mem_map_handle = result->opcode;
789 wake_up(&a->mem_wait);
791 case ASM_CMD_SHARED_MEM_UNMAP_REGIONS:
792 ac->result.opcode = hdr->opcode;
793 ac->result.status = 0;
794 port->mem_map_handle = 0;
795 wake_up(&a->mem_wait);
798 dev_dbg(&adev->dev, "command[0x%x]success [0x%x]\n",
799 result->opcode, result->status);
804 ac->cb(hdr->opcode, hdr->token, data->payload, ac->priv);
807 kref_put(&ac->refcount, q6asm_audio_client_release);
813 * q6asm_get_session_id() - get session id for audio client
815 * @c: audio client pointer
817 * Return: Will be an session id of the audio client.
819 int q6asm_get_session_id(struct audio_client *c)
823 EXPORT_SYMBOL_GPL(q6asm_get_session_id);
826 * q6asm_audio_client_alloc() - Allocate a new audio client
828 * @dev: Pointer to asm child device.
829 * @cb: event callback.
830 * @priv: private data associated with this client.
831 * @session_id: session id
832 * @perf_mode: performace mode for this client
834 * Return: Will be an error pointer on error or a valid audio client
837 struct audio_client *q6asm_audio_client_alloc(struct device *dev, q6asm_cb cb,
838 void *priv, int session_id,
841 struct q6asm *a = dev_get_drvdata(dev->parent);
842 struct audio_client *ac;
845 ac = q6asm_get_audio_client(a, session_id + 1);
847 dev_err(dev, "Audio Client already active\n");
851 ac = kzalloc(sizeof(*ac), GFP_KERNEL);
853 return ERR_PTR(-ENOMEM);
855 spin_lock_irqsave(&a->slock, flags);
856 a->session[session_id + 1] = ac;
857 spin_unlock_irqrestore(&a->slock, flags);
858 ac->session = session_id + 1;
863 ac->io_mode = ASM_SYNC_IO_MODE;
864 ac->perf_mode = perf_mode;
865 /* DSP expects stream id from 1 */
868 kref_init(&ac->refcount);
870 init_waitqueue_head(&ac->cmd_wait);
871 mutex_init(&ac->cmd_lock);
872 spin_lock_init(&ac->lock);
876 EXPORT_SYMBOL_GPL(q6asm_audio_client_alloc);
878 static int q6asm_ac_send_cmd_sync(struct audio_client *ac, struct apr_pkt *pkt)
880 struct apr_hdr *hdr = &pkt->hdr;
883 mutex_lock(&ac->cmd_lock);
884 ac->result.opcode = 0;
885 ac->result.status = 0;
887 rc = apr_send_pkt(ac->adev, pkt);
891 rc = wait_event_timeout(ac->cmd_wait,
892 (ac->result.opcode == hdr->opcode), 5 * HZ);
894 dev_err(ac->dev, "CMD %x timeout\n", hdr->opcode);
899 if (ac->result.status > 0) {
900 dev_err(ac->dev, "DSP returned error[%x]\n",
909 mutex_unlock(&ac->cmd_lock);
914 * q6asm_open_write() - Open audio client for writing
915 * @ac: audio client pointer
916 * @format: audio sample format
917 * @codec_profile: compressed format profile
918 * @bits_per_sample: bits per sample
920 * Return: Will be an negative value on error or zero on success
922 int q6asm_open_write(struct audio_client *ac, uint32_t format,
923 u32 codec_profile, uint16_t bits_per_sample)
925 struct asm_stream_cmd_open_write_v3 *open;
930 pkt_size = APR_HDR_SIZE + sizeof(*open);
932 p = kzalloc(pkt_size, GFP_KERNEL);
937 open = p + APR_HDR_SIZE;
938 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
940 pkt->hdr.opcode = ASM_STREAM_CMD_OPEN_WRITE_V3;
941 open->mode_flags = 0x00;
942 open->mode_flags |= ASM_LEGACY_STREAM_SESSION;
944 /* source endpoint : matrix */
945 open->sink_endpointype = ASM_END_POINT_DEVICE_MATRIX;
946 open->bits_per_sample = bits_per_sample;
947 open->postprocopo_id = ASM_NULL_POPP_TOPOLOGY;
950 case SND_AUDIOCODEC_MP3:
951 open->dec_fmt_id = ASM_MEDIA_FMT_MP3;
953 case FORMAT_LINEAR_PCM:
954 open->dec_fmt_id = ASM_MEDIA_FMT_MULTI_CHANNEL_PCM_V2;
956 case SND_AUDIOCODEC_FLAC:
957 open->dec_fmt_id = ASM_MEDIA_FMT_FLAC;
959 case SND_AUDIOCODEC_WMA:
960 switch (codec_profile) {
961 case SND_AUDIOPROFILE_WMA9:
962 open->dec_fmt_id = ASM_MEDIA_FMT_WMA_V9;
964 case SND_AUDIOPROFILE_WMA10:
965 case SND_AUDIOPROFILE_WMA9_PRO:
966 case SND_AUDIOPROFILE_WMA9_LOSSLESS:
967 case SND_AUDIOPROFILE_WMA10_LOSSLESS:
968 open->dec_fmt_id = ASM_MEDIA_FMT_WMA_V10;
971 dev_err(ac->dev, "Invalid codec profile 0x%x\n",
977 case SND_AUDIOCODEC_ALAC:
978 open->dec_fmt_id = ASM_MEDIA_FMT_ALAC;
980 case SND_AUDIOCODEC_APE:
981 open->dec_fmt_id = ASM_MEDIA_FMT_APE;
984 dev_err(ac->dev, "Invalid format 0x%x\n", format);
989 rc = q6asm_ac_send_cmd_sync(ac, pkt);
993 ac->io_mode |= ASM_TUN_WRITE_IO_MODE;
999 EXPORT_SYMBOL_GPL(q6asm_open_write);
1001 static int __q6asm_run(struct audio_client *ac, uint32_t flags,
1002 uint32_t msw_ts, uint32_t lsw_ts, bool wait)
1004 struct asm_session_cmd_run_v2 *run;
1005 struct apr_pkt *pkt;
1009 pkt_size = APR_HDR_SIZE + sizeof(*run);
1010 p = kzalloc(pkt_size, GFP_ATOMIC);
1015 run = p + APR_HDR_SIZE;
1017 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
1019 pkt->hdr.opcode = ASM_SESSION_CMD_RUN_V2;
1021 run->time_lsw = lsw_ts;
1022 run->time_msw = msw_ts;
1024 rc = q6asm_ac_send_cmd_sync(ac, pkt);
1026 rc = apr_send_pkt(ac->adev, pkt);
1036 * q6asm_run() - start the audio client
1038 * @ac: audio client pointer
1039 * @flags: flags associated with write
1040 * @msw_ts: timestamp msw
1041 * @lsw_ts: timestamp lsw
1043 * Return: Will be an negative value on error or zero on success
1045 int q6asm_run(struct audio_client *ac, uint32_t flags,
1046 uint32_t msw_ts, uint32_t lsw_ts)
1048 return __q6asm_run(ac, flags, msw_ts, lsw_ts, true);
1050 EXPORT_SYMBOL_GPL(q6asm_run);
1053 * q6asm_run_nowait() - start the audio client withou blocking
1055 * @ac: audio client pointer
1056 * @flags: flags associated with write
1057 * @msw_ts: timestamp msw
1058 * @lsw_ts: timestamp lsw
1060 * Return: Will be an negative value on error or zero on success
1062 int q6asm_run_nowait(struct audio_client *ac, uint32_t flags,
1063 uint32_t msw_ts, uint32_t lsw_ts)
1065 return __q6asm_run(ac, flags, msw_ts, lsw_ts, false);
1067 EXPORT_SYMBOL_GPL(q6asm_run_nowait);
1070 * q6asm_media_format_block_multi_ch_pcm() - setup pcm configuration
1072 * @ac: audio client pointer
1073 * @rate: audio sample rate
1074 * @channels: number of audio channels.
1075 * @channel_map: channel map pointer
1076 * @bits_per_sample: bits per sample
1078 * Return: Will be an negative value on error or zero on success
1080 int q6asm_media_format_block_multi_ch_pcm(struct audio_client *ac,
1081 uint32_t rate, uint32_t channels,
1082 u8 channel_map[PCM_MAX_NUM_CHANNEL],
1083 uint16_t bits_per_sample)
1085 struct asm_multi_channel_pcm_fmt_blk_v2 *fmt;
1086 struct apr_pkt *pkt;
1087 u8 *channel_mapping;
1091 pkt_size = APR_HDR_SIZE + sizeof(*fmt);
1092 p = kzalloc(pkt_size, GFP_KERNEL);
1097 fmt = p + APR_HDR_SIZE;
1099 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
1101 pkt->hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2;
1102 fmt->fmt_blk.fmt_blk_size = sizeof(*fmt) - sizeof(fmt->fmt_blk);
1103 fmt->num_channels = channels;
1104 fmt->bits_per_sample = bits_per_sample;
1105 fmt->sample_rate = rate;
1108 channel_mapping = fmt->channel_mapping;
1111 memcpy(channel_mapping, channel_map, PCM_MAX_NUM_CHANNEL);
1113 if (q6dsp_map_channels(channel_mapping, channels)) {
1114 dev_err(ac->dev, " map channels failed %d\n", channels);
1120 rc = q6asm_ac_send_cmd_sync(ac, pkt);
1126 EXPORT_SYMBOL_GPL(q6asm_media_format_block_multi_ch_pcm);
1129 int q6asm_stream_media_format_block_flac(struct audio_client *ac,
1130 struct q6asm_flac_cfg *cfg)
1132 struct asm_flac_fmt_blk_v2 *fmt;
1133 struct apr_pkt *pkt;
1137 pkt_size = APR_HDR_SIZE + sizeof(*fmt);
1138 p = kzalloc(pkt_size, GFP_KERNEL);
1143 fmt = p + APR_HDR_SIZE;
1145 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
1147 pkt->hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2;
1148 fmt->fmt_blk.fmt_blk_size = sizeof(*fmt) - sizeof(fmt->fmt_blk);
1149 fmt->is_stream_info_present = cfg->stream_info_present;
1150 fmt->num_channels = cfg->ch_cfg;
1151 fmt->min_blk_size = cfg->min_blk_size;
1152 fmt->max_blk_size = cfg->max_blk_size;
1153 fmt->sample_rate = cfg->sample_rate;
1154 fmt->min_frame_size = cfg->min_frame_size;
1155 fmt->max_frame_size = cfg->max_frame_size;
1156 fmt->sample_size = cfg->sample_size;
1158 rc = q6asm_ac_send_cmd_sync(ac, pkt);
1163 EXPORT_SYMBOL_GPL(q6asm_stream_media_format_block_flac);
1165 int q6asm_stream_media_format_block_wma_v9(struct audio_client *ac,
1166 struct q6asm_wma_cfg *cfg)
1168 struct asm_wmastdv9_fmt_blk_v2 *fmt;
1169 struct apr_pkt *pkt;
1173 pkt_size = APR_HDR_SIZE + sizeof(*fmt);
1174 p = kzalloc(pkt_size, GFP_KERNEL);
1179 fmt = p + APR_HDR_SIZE;
1181 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
1183 pkt->hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2;
1184 fmt->fmt_blk.fmt_blk_size = sizeof(*fmt) - sizeof(fmt->fmt_blk);
1185 fmt->fmtag = cfg->fmtag;
1186 fmt->num_channels = cfg->num_channels;
1187 fmt->sample_rate = cfg->sample_rate;
1188 fmt->bytes_per_sec = cfg->bytes_per_sec;
1189 fmt->blk_align = cfg->block_align;
1190 fmt->bits_per_sample = cfg->bits_per_sample;
1191 fmt->channel_mask = cfg->channel_mask;
1192 fmt->enc_options = cfg->enc_options;
1195 rc = q6asm_ac_send_cmd_sync(ac, pkt);
1200 EXPORT_SYMBOL_GPL(q6asm_stream_media_format_block_wma_v9);
1202 int q6asm_stream_media_format_block_wma_v10(struct audio_client *ac,
1203 struct q6asm_wma_cfg *cfg)
1205 struct asm_wmaprov10_fmt_blk_v2 *fmt;
1206 struct apr_pkt *pkt;
1210 pkt_size = APR_HDR_SIZE + sizeof(*fmt);
1211 p = kzalloc(pkt_size, GFP_KERNEL);
1216 fmt = p + APR_HDR_SIZE;
1218 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
1220 pkt->hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2;
1221 fmt->fmt_blk.fmt_blk_size = sizeof(*fmt) - sizeof(fmt->fmt_blk);
1222 fmt->fmtag = cfg->fmtag;
1223 fmt->num_channels = cfg->num_channels;
1224 fmt->sample_rate = cfg->sample_rate;
1225 fmt->bytes_per_sec = cfg->bytes_per_sec;
1226 fmt->blk_align = cfg->block_align;
1227 fmt->bits_per_sample = cfg->bits_per_sample;
1228 fmt->channel_mask = cfg->channel_mask;
1229 fmt->enc_options = cfg->enc_options;
1230 fmt->advanced_enc_options1 = cfg->adv_enc_options;
1231 fmt->advanced_enc_options2 = cfg->adv_enc_options2;
1233 rc = q6asm_ac_send_cmd_sync(ac, pkt);
1238 EXPORT_SYMBOL_GPL(q6asm_stream_media_format_block_wma_v10);
1240 int q6asm_stream_media_format_block_alac(struct audio_client *ac,
1241 struct q6asm_alac_cfg *cfg)
1243 struct asm_alac_fmt_blk_v2 *fmt;
1244 struct apr_pkt *pkt;
1248 pkt_size = APR_HDR_SIZE + sizeof(*fmt);
1249 p = kzalloc(pkt_size, GFP_KERNEL);
1254 fmt = p + APR_HDR_SIZE;
1256 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
1258 pkt->hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2;
1259 fmt->fmt_blk.fmt_blk_size = sizeof(*fmt) - sizeof(fmt->fmt_blk);
1261 fmt->frame_length = cfg->frame_length;
1262 fmt->compatible_version = cfg->compatible_version;
1263 fmt->bit_depth = cfg->bit_depth;
1264 fmt->num_channels = cfg->num_channels;
1265 fmt->max_run = cfg->max_run;
1266 fmt->max_frame_bytes = cfg->max_frame_bytes;
1267 fmt->avg_bit_rate = cfg->avg_bit_rate;
1268 fmt->sample_rate = cfg->sample_rate;
1269 fmt->channel_layout_tag = cfg->channel_layout_tag;
1274 rc = q6asm_ac_send_cmd_sync(ac, pkt);
1279 EXPORT_SYMBOL_GPL(q6asm_stream_media_format_block_alac);
1281 int q6asm_stream_media_format_block_ape(struct audio_client *ac,
1282 struct q6asm_ape_cfg *cfg)
1284 struct asm_ape_fmt_blk_v2 *fmt;
1285 struct apr_pkt *pkt;
1289 pkt_size = APR_HDR_SIZE + sizeof(*fmt);
1290 p = kzalloc(pkt_size, GFP_KERNEL);
1295 fmt = p + APR_HDR_SIZE;
1297 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
1299 pkt->hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2;
1300 fmt->fmt_blk.fmt_blk_size = sizeof(*fmt) - sizeof(fmt->fmt_blk);
1302 fmt->compatible_version = cfg->compatible_version;
1303 fmt->compression_level = cfg->compression_level;
1304 fmt->format_flags = cfg->format_flags;
1305 fmt->blocks_per_frame = cfg->blocks_per_frame;
1306 fmt->final_frame_blocks = cfg->final_frame_blocks;
1307 fmt->total_frames = cfg->total_frames;
1308 fmt->bits_per_sample = cfg->bits_per_sample;
1309 fmt->num_channels = cfg->num_channels;
1310 fmt->sample_rate = cfg->sample_rate;
1311 fmt->seek_table_present = cfg->seek_table_present;
1313 rc = q6asm_ac_send_cmd_sync(ac, pkt);
1318 EXPORT_SYMBOL_GPL(q6asm_stream_media_format_block_ape);
1321 * q6asm_enc_cfg_blk_pcm_format_support() - setup pcm configuration for capture
1323 * @ac: audio client pointer
1324 * @rate: audio sample rate
1325 * @channels: number of audio channels.
1326 * @bits_per_sample: bits per sample
1328 * Return: Will be an negative value on error or zero on success
1330 int q6asm_enc_cfg_blk_pcm_format_support(struct audio_client *ac,
1331 uint32_t rate, uint32_t channels, uint16_t bits_per_sample)
1333 struct asm_multi_channel_pcm_enc_cfg_v2 *enc_cfg;
1334 struct apr_pkt *pkt;
1335 u8 *channel_mapping;
1336 u32 frames_per_buf = 0;
1340 pkt_size = APR_HDR_SIZE + sizeof(*enc_cfg);
1341 p = kzalloc(pkt_size, GFP_KERNEL);
1346 enc_cfg = p + APR_HDR_SIZE;
1347 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
1349 pkt->hdr.opcode = ASM_STREAM_CMD_SET_ENCDEC_PARAM;
1350 enc_cfg->encdec.param_id = ASM_PARAM_ID_ENCDEC_ENC_CFG_BLK_V2;
1351 enc_cfg->encdec.param_size = sizeof(*enc_cfg) - sizeof(enc_cfg->encdec);
1352 enc_cfg->encblk.frames_per_buf = frames_per_buf;
1353 enc_cfg->encblk.enc_cfg_blk_size = enc_cfg->encdec.param_size -
1354 sizeof(struct asm_enc_cfg_blk_param_v2);
1356 enc_cfg->num_channels = channels;
1357 enc_cfg->bits_per_sample = bits_per_sample;
1358 enc_cfg->sample_rate = rate;
1359 enc_cfg->is_signed = 1;
1360 channel_mapping = enc_cfg->channel_mapping;
1362 if (q6dsp_map_channels(channel_mapping, channels)) {
1367 rc = q6asm_ac_send_cmd_sync(ac, pkt);
1372 EXPORT_SYMBOL_GPL(q6asm_enc_cfg_blk_pcm_format_support);
1376 * q6asm_read() - read data of period size from audio client
1378 * @ac: audio client pointer
1380 * Return: Will be an negative value on error or zero on success
1382 int q6asm_read(struct audio_client *ac)
1384 struct asm_data_cmd_read_v2 *read;
1385 struct audio_port_data *port;
1386 struct audio_buffer *ab;
1387 struct apr_pkt *pkt;
1388 unsigned long flags;
1393 pkt_size = APR_HDR_SIZE + sizeof(*read);
1394 p = kzalloc(pkt_size, GFP_ATOMIC);
1399 read = p + APR_HDR_SIZE;
1401 spin_lock_irqsave(&ac->lock, flags);
1402 port = &ac->port[SNDRV_PCM_STREAM_CAPTURE];
1403 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, false, ac->stream_id);
1404 ab = &port->buf[port->dsp_buf];
1405 pkt->hdr.opcode = ASM_DATA_CMD_READ_V2;
1406 read->buf_addr_lsw = lower_32_bits(ab->phys);
1407 read->buf_addr_msw = upper_32_bits(ab->phys);
1408 read->mem_map_handle = port->mem_map_handle;
1410 read->buf_size = ab->size;
1411 read->seq_id = port->dsp_buf;
1412 pkt->hdr.token = port->dsp_buf;
1416 if (port->dsp_buf >= port->num_periods)
1419 spin_unlock_irqrestore(&ac->lock, flags);
1420 rc = apr_send_pkt(ac->adev, pkt);
1424 pr_err("read op[0x%x]rc[%d]\n", pkt->hdr.opcode, rc);
1429 EXPORT_SYMBOL_GPL(q6asm_read);
1431 static int __q6asm_open_read(struct audio_client *ac,
1432 uint32_t format, uint16_t bits_per_sample)
1434 struct asm_stream_cmd_open_read_v3 *open;
1435 struct apr_pkt *pkt;
1439 pkt_size = APR_HDR_SIZE + sizeof(*open);
1440 p = kzalloc(pkt_size, GFP_KERNEL);
1445 open = p + APR_HDR_SIZE;
1447 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
1448 pkt->hdr.opcode = ASM_STREAM_CMD_OPEN_READ_V3;
1449 /* Stream prio : High, provide meta info with encoded frames */
1450 open->src_endpointype = ASM_END_POINT_DEVICE_MATRIX;
1452 open->preprocopo_id = ASM_STREAM_POSTPROC_TOPO_ID_NONE;
1453 open->bits_per_sample = bits_per_sample;
1454 open->mode_flags = 0x0;
1456 open->mode_flags |= ASM_LEGACY_STREAM_SESSION <<
1457 ASM_SHIFT_STREAM_PERF_MODE_FLAG_IN_OPEN_READ;
1460 case FORMAT_LINEAR_PCM:
1461 open->mode_flags |= 0x00;
1462 open->enc_cfg_id = ASM_MEDIA_FMT_MULTI_CHANNEL_PCM_V2;
1465 pr_err("Invalid format[%d]\n", format);
1468 rc = q6asm_ac_send_cmd_sync(ac, pkt);
1475 * q6asm_open_read() - Open audio client for reading
1477 * @ac: audio client pointer
1478 * @format: audio sample format
1479 * @bits_per_sample: bits per sample
1481 * Return: Will be an negative value on error or zero on success
1483 int q6asm_open_read(struct audio_client *ac, uint32_t format,
1484 uint16_t bits_per_sample)
1486 return __q6asm_open_read(ac, format, bits_per_sample);
1488 EXPORT_SYMBOL_GPL(q6asm_open_read);
1491 * q6asm_write_async() - non blocking write
1493 * @ac: audio client pointer
1494 * @len: length in bytes
1495 * @msw_ts: timestamp msw
1496 * @lsw_ts: timestamp lsw
1497 * @wflags: flags associated with write
1499 * Return: Will be an negative value on error or zero on success
1501 int q6asm_write_async(struct audio_client *ac, uint32_t len, uint32_t msw_ts,
1502 uint32_t lsw_ts, uint32_t wflags)
1504 struct asm_data_cmd_write_v2 *write;
1505 struct audio_port_data *port;
1506 struct audio_buffer *ab;
1507 unsigned long flags;
1508 struct apr_pkt *pkt;
1513 pkt_size = APR_HDR_SIZE + sizeof(*write);
1514 p = kzalloc(pkt_size, GFP_ATOMIC);
1519 write = p + APR_HDR_SIZE;
1521 spin_lock_irqsave(&ac->lock, flags);
1522 port = &ac->port[SNDRV_PCM_STREAM_PLAYBACK];
1523 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, false, ac->stream_id);
1525 ab = &port->buf[port->dsp_buf];
1526 pkt->hdr.token = port->dsp_buf;
1527 pkt->hdr.opcode = ASM_DATA_CMD_WRITE_V2;
1528 write->buf_addr_lsw = lower_32_bits(ab->phys);
1529 write->buf_addr_msw = upper_32_bits(ab->phys);
1530 write->buf_size = len;
1531 write->seq_id = port->dsp_buf;
1532 write->timestamp_lsw = lsw_ts;
1533 write->timestamp_msw = msw_ts;
1534 write->mem_map_handle =
1535 ac->port[SNDRV_PCM_STREAM_PLAYBACK].mem_map_handle;
1537 if (wflags == NO_TIMESTAMP)
1538 write->flags = (wflags & 0x800000FF);
1540 write->flags = (0x80000000 | wflags);
1544 if (port->dsp_buf >= port->num_periods)
1547 spin_unlock_irqrestore(&ac->lock, flags);
1548 rc = apr_send_pkt(ac->adev, pkt);
1555 EXPORT_SYMBOL_GPL(q6asm_write_async);
1557 static void q6asm_reset_buf_state(struct audio_client *ac)
1559 struct audio_port_data *port = NULL;
1560 unsigned long flags;
1562 spin_lock_irqsave(&ac->lock, flags);
1563 port = &ac->port[SNDRV_PCM_STREAM_PLAYBACK];
1565 port = &ac->port[SNDRV_PCM_STREAM_CAPTURE];
1567 spin_unlock_irqrestore(&ac->lock, flags);
1570 static int __q6asm_cmd(struct audio_client *ac, int cmd, bool wait)
1572 int stream_id = ac->stream_id;
1576 q6asm_add_hdr(ac, &pkt.hdr, APR_HDR_SIZE, true, stream_id);
1580 pkt.hdr.opcode = ASM_SESSION_CMD_PAUSE;
1583 pkt.hdr.opcode = ASM_SESSION_CMD_SUSPEND;
1586 pkt.hdr.opcode = ASM_STREAM_CMD_FLUSH;
1589 pkt.hdr.opcode = ASM_STREAM_CMD_FLUSH_READBUFS;
1592 pkt.hdr.opcode = ASM_DATA_CMD_EOS;
1595 pkt.hdr.opcode = ASM_STREAM_CMD_CLOSE;
1602 rc = q6asm_ac_send_cmd_sync(ac, &pkt);
1604 return apr_send_pkt(ac->adev, &pkt);
1609 if (cmd == CMD_FLUSH)
1610 q6asm_reset_buf_state(ac);
1616 * q6asm_cmd() - run cmd on audio client
1618 * @ac: audio client pointer
1619 * @cmd: command to run on audio client.
1621 * Return: Will be an negative value on error or zero on success
1623 int q6asm_cmd(struct audio_client *ac, int cmd)
1625 return __q6asm_cmd(ac, cmd, true);
1627 EXPORT_SYMBOL_GPL(q6asm_cmd);
1630 * q6asm_cmd_nowait() - non blocking, run cmd on audio client
1632 * @ac: audio client pointer
1633 * @cmd: command to run on audio client.
1635 * Return: Will be an negative value on error or zero on success
1637 int q6asm_cmd_nowait(struct audio_client *ac, int cmd)
1639 return __q6asm_cmd(ac, cmd, false);
1641 EXPORT_SYMBOL_GPL(q6asm_cmd_nowait);
1643 static int q6asm_probe(struct apr_device *adev)
1645 struct device *dev = &adev->dev;
1646 struct q6asm *q6asm;
1648 q6asm = devm_kzalloc(dev, sizeof(*q6asm), GFP_KERNEL);
1652 q6core_get_svc_api_info(adev->svc_id, &q6asm->ainfo);
1656 init_waitqueue_head(&q6asm->mem_wait);
1657 spin_lock_init(&q6asm->slock);
1658 dev_set_drvdata(dev, q6asm);
1660 return of_platform_populate(dev->of_node, NULL, NULL, dev);
1663 static int q6asm_remove(struct apr_device *adev)
1665 of_platform_depopulate(&adev->dev);
1669 static const struct of_device_id q6asm_device_id[] = {
1670 { .compatible = "qcom,q6asm" },
1673 MODULE_DEVICE_TABLE(of, q6asm_device_id);
1675 static struct apr_driver qcom_q6asm_driver = {
1676 .probe = q6asm_probe,
1677 .remove = q6asm_remove,
1678 .callback = q6asm_srvc_callback,
1680 .name = "qcom-q6asm",
1681 .of_match_table = of_match_ptr(q6asm_device_id),
1685 module_apr_driver(qcom_q6asm_driver);
1686 MODULE_DESCRIPTION("Q6 Audio Stream Manager driver");
1687 MODULE_LICENSE("GPL v2");