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 <linux/of_platform.h>
15 #include <uapi/sound/asound.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_DATA_CMD_WRITE_V2 0x00010DAB
42 #define ASM_DATA_CMD_READ_V2 0x00010DAC
43 #define ASM_SESSION_CMD_SUSPEND 0x00010DEC
44 #define ASM_STREAM_CMD_OPEN_WRITE_V3 0x00010DB3
45 #define ASM_STREAM_CMD_OPEN_READ_V3 0x00010DB4
46 #define ASM_DATA_EVENT_READ_DONE_V2 0x00010D9A
47 #define ASM_STREAM_CMD_OPEN_READWRITE_V2 0x00010D8D
50 #define ASM_LEGACY_STREAM_SESSION 0
51 /* Bit shift for the stream_perf_mode subfield. */
52 #define ASM_SHIFT_STREAM_PERF_MODE_FLAG_IN_OPEN_READ 29
53 #define ASM_END_POINT_DEVICE_MATRIX 0
54 #define ASM_DEFAULT_APP_TYPE 0
55 #define ASM_SYNC_IO_MODE 0x0001
56 #define ASM_ASYNC_IO_MODE 0x0002
57 #define ASM_TUN_READ_IO_MODE 0x0004 /* tunnel read write mode */
58 #define ASM_TUN_WRITE_IO_MODE 0x0008 /* tunnel read write mode */
59 #define ASM_SHIFT_GAPLESS_MODE_FLAG 31
60 #define ADSP_MEMORY_MAP_SHMEM8_4K_POOL 3
62 struct avs_cmd_shared_mem_map_regions {
68 struct avs_shared_map_region_payload {
74 struct avs_cmd_shared_mem_unmap_regions {
78 struct asm_data_cmd_media_fmt_update_v2 {
82 struct asm_multi_channel_pcm_fmt_blk_v2 {
83 struct asm_data_cmd_media_fmt_update_v2 fmt_blk;
89 u8 channel_mapping[PCM_MAX_NUM_CHANNEL];
92 struct asm_stream_cmd_set_encdec_param {
97 struct asm_enc_cfg_blk_param_v2 {
102 struct asm_multi_channel_pcm_enc_cfg_v2 {
103 struct asm_stream_cmd_set_encdec_param encdec;
104 struct asm_enc_cfg_blk_param_v2 encblk;
105 uint16_t num_channels;
106 uint16_t bits_per_sample;
107 uint32_t sample_rate;
110 uint8_t channel_mapping[8];
113 struct asm_data_cmd_read_v2 {
121 struct asm_data_cmd_read_v2_done {
127 struct asm_stream_cmd_open_read_v3 {
136 struct asm_data_cmd_write_v2 {
147 struct asm_stream_cmd_open_write_v3 {
149 uint16_t sink_endpointype;
150 uint16_t bits_per_sample;
151 uint32_t postprocopo_id;
155 struct asm_session_cmd_run_v2 {
161 struct audio_buffer {
163 uint32_t size; /* size of buffer */
166 struct audio_port_data {
167 struct audio_buffer *buf;
168 uint32_t num_periods;
170 uint32_t mem_map_handle;
174 struct apr_device *adev;
176 struct q6core_svc_api_info ainfo;
177 wait_queue_head_t mem_wait;
179 struct audio_client *session[MAX_SESSIONS + 1];
182 struct audio_client {
187 struct apr_device *adev;
188 struct mutex cmd_lock;
190 struct kref refcount;
191 /* idx:1 out port, 0: in port */
192 struct audio_port_data port[2];
193 wait_queue_head_t cmd_wait;
194 struct aprv2_ibasic_rsp_result_t result;
201 static inline void q6asm_add_hdr(struct audio_client *ac, struct apr_hdr *hdr,
202 uint32_t pkt_size, bool cmd_flg,
205 hdr->hdr_field = APR_SEQ_CMD_HDR_FIELD;
206 hdr->src_port = ((ac->session << 8) & 0xFF00) | (stream_id);
207 hdr->dest_port = ((ac->session << 8) & 0xFF00) | (stream_id);
208 hdr->pkt_size = pkt_size;
210 hdr->token = ac->session;
213 static int q6asm_apr_send_session_pkt(struct q6asm *a, struct audio_client *ac,
214 struct apr_pkt *pkt, uint32_t rsp_opcode)
216 struct apr_hdr *hdr = &pkt->hdr;
219 mutex_lock(&ac->cmd_lock);
220 ac->result.opcode = 0;
221 ac->result.status = 0;
222 rc = apr_send_pkt(a->adev, pkt);
227 rc = wait_event_timeout(a->mem_wait,
228 (ac->result.opcode == hdr->opcode) ||
229 (ac->result.opcode == rsp_opcode),
232 rc = wait_event_timeout(a->mem_wait,
233 (ac->result.opcode == hdr->opcode),
237 dev_err(a->dev, "CMD timeout\n");
239 } else if (ac->result.status > 0) {
240 dev_err(a->dev, "DSP returned error[%x]\n",
246 mutex_unlock(&ac->cmd_lock);
250 static int __q6asm_memory_unmap(struct audio_client *ac,
251 phys_addr_t buf_add, int dir)
253 struct avs_cmd_shared_mem_unmap_regions *mem_unmap;
254 struct q6asm *a = dev_get_drvdata(ac->dev->parent);
259 if (ac->port[dir].mem_map_handle == 0) {
260 dev_err(ac->dev, "invalid mem handle\n");
264 pkt_size = APR_HDR_SIZE + sizeof(*mem_unmap);
265 p = kzalloc(pkt_size, GFP_KERNEL);
270 mem_unmap = p + APR_HDR_SIZE;
272 pkt->hdr.hdr_field = APR_SEQ_CMD_HDR_FIELD;
273 pkt->hdr.src_port = 0;
274 pkt->hdr.dest_port = 0;
275 pkt->hdr.pkt_size = pkt_size;
276 pkt->hdr.token = ((ac->session << 8) | dir);
278 pkt->hdr.opcode = ASM_CMD_SHARED_MEM_UNMAP_REGIONS;
279 mem_unmap->mem_map_handle = ac->port[dir].mem_map_handle;
281 rc = q6asm_apr_send_session_pkt(a, ac, pkt, 0);
287 ac->port[dir].mem_map_handle = 0;
294 static void q6asm_audio_client_free_buf(struct audio_client *ac,
295 struct audio_port_data *port)
299 spin_lock_irqsave(&ac->lock, flags);
300 port->num_periods = 0;
303 spin_unlock_irqrestore(&ac->lock, flags);
307 * q6asm_unmap_memory_regions() - unmap memory regions in the dsp.
309 * @dir: direction of audio stream
310 * @ac: audio client instanace
312 * Return: Will be an negative value on failure or zero on success
314 int q6asm_unmap_memory_regions(unsigned int dir, struct audio_client *ac)
316 struct audio_port_data *port;
320 port = &ac->port[dir];
326 cnt = port->num_periods - 1;
328 rc = __q6asm_memory_unmap(ac, port->buf[dir].phys, dir);
330 dev_err(ac->dev, "%s: Memory_unmap_regions failed %d\n",
336 q6asm_audio_client_free_buf(ac, port);
341 EXPORT_SYMBOL_GPL(q6asm_unmap_memory_regions);
343 static int __q6asm_memory_map_regions(struct audio_client *ac, int dir,
344 size_t period_sz, unsigned int periods,
347 struct avs_cmd_shared_mem_map_regions *cmd = NULL;
348 struct avs_shared_map_region_payload *mregions = NULL;
349 struct q6asm *a = dev_get_drvdata(ac->dev->parent);
350 struct audio_port_data *port = NULL;
351 struct audio_buffer *ab = NULL;
355 uint32_t num_regions, buf_sz;
360 buf_sz = period_sz * periods;
363 num_regions = periods;
366 /* DSP expects size should be aligned to 4K */
367 buf_sz = ALIGN(buf_sz, 4096);
369 pkt_size = APR_HDR_SIZE + sizeof(*cmd) +
370 (sizeof(*mregions) * num_regions);
372 p = kzalloc(pkt_size, GFP_KERNEL);
377 cmd = p + APR_HDR_SIZE;
378 mregions = p + APR_HDR_SIZE + sizeof(*cmd);
380 pkt->hdr.hdr_field = APR_SEQ_CMD_HDR_FIELD;
381 pkt->hdr.src_port = 0;
382 pkt->hdr.dest_port = 0;
383 pkt->hdr.pkt_size = pkt_size;
384 pkt->hdr.token = ((ac->session << 8) | dir);
385 pkt->hdr.opcode = ASM_CMD_SHARED_MEM_MAP_REGIONS;
387 cmd->mem_pool_id = ADSP_MEMORY_MAP_SHMEM8_4K_POOL;
388 cmd->num_regions = num_regions;
389 cmd->property_flag = 0x00;
391 spin_lock_irqsave(&ac->lock, flags);
392 port = &ac->port[dir];
394 for (i = 0; i < num_regions; i++) {
396 mregions->shm_addr_lsw = lower_32_bits(ab->phys);
397 mregions->shm_addr_msw = upper_32_bits(ab->phys);
398 mregions->mem_size_bytes = buf_sz;
401 spin_unlock_irqrestore(&ac->lock, flags);
403 rc = q6asm_apr_send_session_pkt(a, ac, pkt,
404 ASM_CMDRSP_SHARED_MEM_MAP_REGIONS);
412 * q6asm_map_memory_regions() - map memory regions in the dsp.
414 * @dir: direction of audio stream
415 * @ac: audio client instanace
416 * @phys: physcial address that needs mapping.
417 * @period_sz: audio period size
418 * @periods: number of periods
420 * Return: Will be an negative value on failure or zero on success
422 int q6asm_map_memory_regions(unsigned int dir, struct audio_client *ac,
424 size_t period_sz, unsigned int periods)
426 struct audio_buffer *buf;
431 spin_lock_irqsave(&ac->lock, flags);
432 if (ac->port[dir].buf) {
433 dev_err(ac->dev, "Buffer already allocated\n");
434 spin_unlock_irqrestore(&ac->lock, flags);
438 buf = kzalloc(((sizeof(struct audio_buffer)) * periods), GFP_ATOMIC);
440 spin_unlock_irqrestore(&ac->lock, flags);
445 ac->port[dir].buf = buf;
448 buf[0].size = period_sz;
450 for (cnt = 1; cnt < periods; cnt++) {
452 buf[cnt].phys = buf[0].phys + (cnt * period_sz);
453 buf[cnt].size = period_sz;
456 ac->port[dir].num_periods = periods;
458 spin_unlock_irqrestore(&ac->lock, flags);
460 rc = __q6asm_memory_map_regions(ac, dir, period_sz, periods, 1);
462 dev_err(ac->dev, "Memory_map_regions failed\n");
463 q6asm_audio_client_free_buf(ac, &ac->port[dir]);
468 EXPORT_SYMBOL_GPL(q6asm_map_memory_regions);
470 static void q6asm_audio_client_release(struct kref *ref)
472 struct audio_client *ac;
476 ac = container_of(ref, struct audio_client, refcount);
479 spin_lock_irqsave(&a->slock, flags);
480 a->session[ac->session] = NULL;
481 spin_unlock_irqrestore(&a->slock, flags);
487 * q6asm_audio_client_free() - Freee allocated audio client
489 * @ac: audio client to free
491 void q6asm_audio_client_free(struct audio_client *ac)
493 kref_put(&ac->refcount, q6asm_audio_client_release);
495 EXPORT_SYMBOL_GPL(q6asm_audio_client_free);
497 static struct audio_client *q6asm_get_audio_client(struct q6asm *a,
500 struct audio_client *ac = NULL;
503 spin_lock_irqsave(&a->slock, flags);
504 if ((session_id <= 0) || (session_id > MAX_SESSIONS)) {
505 dev_err(a->dev, "invalid session: %d\n", session_id);
509 /* check for valid session */
510 if (!a->session[session_id])
512 else if (a->session[session_id]->session != session_id)
515 ac = a->session[session_id];
516 kref_get(&ac->refcount);
518 spin_unlock_irqrestore(&a->slock, flags);
522 static int32_t q6asm_stream_callback(struct apr_device *adev,
523 struct apr_resp_pkt *data,
526 struct q6asm *q6asm = dev_get_drvdata(&adev->dev);
527 struct aprv2_ibasic_rsp_result_t *result;
528 struct apr_hdr *hdr = &data->hdr;
529 struct audio_port_data *port;
530 struct audio_client *ac;
531 uint32_t client_event = 0;
534 ac = q6asm_get_audio_client(q6asm, session_id);
535 if (!ac)/* Audio client might already be freed by now */
538 result = data->payload;
540 switch (hdr->opcode) {
541 case APR_BASIC_RSP_RESULT:
542 switch (result->opcode) {
543 case ASM_SESSION_CMD_PAUSE:
544 client_event = ASM_CLIENT_EVENT_CMD_PAUSE_DONE;
546 case ASM_SESSION_CMD_SUSPEND:
547 client_event = ASM_CLIENT_EVENT_CMD_SUSPEND_DONE;
549 case ASM_STREAM_CMD_FLUSH:
550 client_event = ASM_CLIENT_EVENT_CMD_FLUSH_DONE;
552 case ASM_SESSION_CMD_RUN_V2:
553 client_event = ASM_CLIENT_EVENT_CMD_RUN_DONE;
555 case ASM_STREAM_CMD_CLOSE:
556 client_event = ASM_CLIENT_EVENT_CMD_CLOSE_DONE;
558 case ASM_STREAM_CMD_FLUSH_READBUFS:
559 client_event = ASM_CLIENT_EVENT_CMD_OUT_FLUSH_DONE;
561 case ASM_STREAM_CMD_OPEN_WRITE_V3:
562 case ASM_STREAM_CMD_OPEN_READ_V3:
563 case ASM_STREAM_CMD_OPEN_READWRITE_V2:
564 case ASM_STREAM_CMD_SET_ENCDEC_PARAM:
565 case ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2:
566 if (result->status != 0) {
568 "cmd = 0x%x returned error = 0x%x\n",
569 result->opcode, result->status);
570 ac->result = *result;
571 wake_up(&ac->cmd_wait);
577 dev_err(ac->dev, "command[0x%x] not expecting rsp\n",
582 ac->result = *result;
583 wake_up(&ac->cmd_wait);
586 ac->cb(client_event, hdr->token,
587 data->payload, ac->priv);
592 case ASM_DATA_EVENT_WRITE_DONE_V2:
593 client_event = ASM_CLIENT_EVENT_DATA_WRITE_DONE;
594 if (ac->io_mode & ASM_SYNC_IO_MODE) {
598 spin_lock_irqsave(&ac->lock, flags);
600 port = &ac->port[SNDRV_PCM_STREAM_PLAYBACK];
603 spin_unlock_irqrestore(&ac->lock, flags);
608 phys = port->buf[hdr->token].phys;
610 if (lower_32_bits(phys) != result->opcode ||
611 upper_32_bits(phys) != result->status) {
612 dev_err(ac->dev, "Expected addr %pa\n",
613 &port->buf[hdr->token].phys);
614 spin_unlock_irqrestore(&ac->lock, flags);
618 spin_unlock_irqrestore(&ac->lock, flags);
621 case ASM_DATA_EVENT_READ_DONE_V2:
622 client_event = ASM_CLIENT_EVENT_DATA_READ_DONE;
623 if (ac->io_mode & ASM_SYNC_IO_MODE) {
624 struct asm_data_cmd_read_v2_done *done = data->payload;
628 spin_lock_irqsave(&ac->lock, flags);
629 port = &ac->port[SNDRV_PCM_STREAM_CAPTURE];
631 spin_unlock_irqrestore(&ac->lock, flags);
636 phys = port->buf[hdr->token].phys;
638 if (upper_32_bits(phys) != done->buf_addr_msw ||
639 lower_32_bits(phys) != done->buf_addr_lsw) {
640 dev_err(ac->dev, "Expected addr %pa %08x-%08x\n",
641 &port->buf[hdr->token].phys,
644 spin_unlock_irqrestore(&ac->lock, flags);
648 spin_unlock_irqrestore(&ac->lock, flags);
652 case ASM_DATA_EVENT_RENDERED_EOS:
653 client_event = ASM_CLIENT_EVENT_CMD_EOS_DONE;
658 ac->cb(client_event, hdr->token, data->payload, ac->priv);
661 kref_put(&ac->refcount, q6asm_audio_client_release);
665 static int q6asm_srvc_callback(struct apr_device *adev,
666 struct apr_resp_pkt *data)
668 struct q6asm *q6asm = dev_get_drvdata(&adev->dev);
669 struct aprv2_ibasic_rsp_result_t *result;
670 struct audio_port_data *port;
671 struct audio_client *ac = NULL;
672 struct apr_hdr *hdr = &data->hdr;
678 session_id = (hdr->dest_port >> 8) & 0xFF;
680 return q6asm_stream_callback(adev, data, session_id);
682 sid = (hdr->token >> 8) & 0x0F;
683 ac = q6asm_get_audio_client(q6asm, sid);
685 dev_err(&adev->dev, "Audio Client not active\n");
689 a = dev_get_drvdata(ac->dev->parent);
690 dir = (hdr->token & 0x0F);
691 port = &ac->port[dir];
692 result = data->payload;
694 switch (hdr->opcode) {
695 case APR_BASIC_RSP_RESULT:
696 switch (result->opcode) {
697 case ASM_CMD_SHARED_MEM_MAP_REGIONS:
698 case ASM_CMD_SHARED_MEM_UNMAP_REGIONS:
699 ac->result = *result;
700 wake_up(&a->mem_wait);
703 dev_err(&adev->dev, "command[0x%x] not expecting rsp\n",
708 case ASM_CMDRSP_SHARED_MEM_MAP_REGIONS:
709 ac->result.status = 0;
710 ac->result.opcode = hdr->opcode;
711 port->mem_map_handle = result->opcode;
712 wake_up(&a->mem_wait);
714 case ASM_CMD_SHARED_MEM_UNMAP_REGIONS:
715 ac->result.opcode = hdr->opcode;
716 ac->result.status = 0;
717 port->mem_map_handle = 0;
718 wake_up(&a->mem_wait);
721 dev_dbg(&adev->dev, "command[0x%x]success [0x%x]\n",
722 result->opcode, result->status);
727 ac->cb(hdr->opcode, hdr->token, data->payload, ac->priv);
730 kref_put(&ac->refcount, q6asm_audio_client_release);
736 * q6asm_get_session_id() - get session id for audio client
738 * @c: audio client pointer
740 * Return: Will be an session id of the audio client.
742 int q6asm_get_session_id(struct audio_client *c)
746 EXPORT_SYMBOL_GPL(q6asm_get_session_id);
749 * q6asm_audio_client_alloc() - Allocate a new audio client
751 * @dev: Pointer to asm child device.
752 * @cb: event callback.
753 * @priv: private data associated with this client.
754 * @stream_id: stream id
755 * @perf_mode: performace mode for this client
757 * Return: Will be an error pointer on error or a valid audio client
760 struct audio_client *q6asm_audio_client_alloc(struct device *dev, q6asm_cb cb,
761 void *priv, int stream_id,
764 struct q6asm *a = dev_get_drvdata(dev->parent);
765 struct audio_client *ac;
768 ac = q6asm_get_audio_client(a, stream_id + 1);
770 dev_err(dev, "Audio Client already active\n");
774 ac = kzalloc(sizeof(*ac), GFP_KERNEL);
776 return ERR_PTR(-ENOMEM);
778 spin_lock_irqsave(&a->slock, flags);
779 a->session[stream_id + 1] = ac;
780 spin_unlock_irqrestore(&a->slock, flags);
781 ac->session = stream_id + 1;
786 ac->io_mode = ASM_SYNC_IO_MODE;
787 ac->perf_mode = perf_mode;
788 /* DSP expects stream id from 1 */
791 kref_init(&ac->refcount);
793 init_waitqueue_head(&ac->cmd_wait);
794 mutex_init(&ac->cmd_lock);
795 spin_lock_init(&ac->lock);
799 EXPORT_SYMBOL_GPL(q6asm_audio_client_alloc);
801 static int q6asm_ac_send_cmd_sync(struct audio_client *ac, struct apr_pkt *pkt)
803 struct apr_hdr *hdr = &pkt->hdr;
806 mutex_lock(&ac->cmd_lock);
807 ac->result.opcode = 0;
808 ac->result.status = 0;
810 rc = apr_send_pkt(ac->adev, pkt);
814 rc = wait_event_timeout(ac->cmd_wait,
815 (ac->result.opcode == hdr->opcode), 5 * HZ);
817 dev_err(ac->dev, "CMD timeout\n");
822 if (ac->result.status > 0) {
823 dev_err(ac->dev, "DSP returned error[%x]\n",
832 mutex_unlock(&ac->cmd_lock);
837 * q6asm_open_write() - Open audio client for writing
839 * @ac: audio client pointer
840 * @format: audio sample format
841 * @bits_per_sample: bits per sample
843 * Return: Will be an negative value on error or zero on success
845 int q6asm_open_write(struct audio_client *ac, uint32_t format,
846 uint16_t bits_per_sample)
848 struct asm_stream_cmd_open_write_v3 *open;
853 pkt_size = APR_HDR_SIZE + sizeof(*open);
855 p = kzalloc(pkt_size, GFP_KERNEL);
860 open = p + APR_HDR_SIZE;
861 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
863 pkt->hdr.opcode = ASM_STREAM_CMD_OPEN_WRITE_V3;
864 open->mode_flags = 0x00;
865 open->mode_flags |= ASM_LEGACY_STREAM_SESSION;
867 /* source endpoint : matrix */
868 open->sink_endpointype = ASM_END_POINT_DEVICE_MATRIX;
869 open->bits_per_sample = bits_per_sample;
870 open->postprocopo_id = ASM_NULL_POPP_TOPOLOGY;
873 case FORMAT_LINEAR_PCM:
874 open->dec_fmt_id = ASM_MEDIA_FMT_MULTI_CHANNEL_PCM_V2;
877 dev_err(ac->dev, "Invalid format 0x%x\n", format);
882 rc = q6asm_ac_send_cmd_sync(ac, pkt);
886 ac->io_mode |= ASM_TUN_WRITE_IO_MODE;
892 EXPORT_SYMBOL_GPL(q6asm_open_write);
894 static int __q6asm_run(struct audio_client *ac, uint32_t flags,
895 uint32_t msw_ts, uint32_t lsw_ts, bool wait)
897 struct asm_session_cmd_run_v2 *run;
902 pkt_size = APR_HDR_SIZE + sizeof(*run);
903 p = kzalloc(pkt_size, GFP_ATOMIC);
908 run = p + APR_HDR_SIZE;
910 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
912 pkt->hdr.opcode = ASM_SESSION_CMD_RUN_V2;
914 run->time_lsw = lsw_ts;
915 run->time_msw = msw_ts;
917 rc = q6asm_ac_send_cmd_sync(ac, pkt);
919 rc = apr_send_pkt(ac->adev, pkt);
929 * q6asm_run() - start the audio client
931 * @ac: audio client pointer
932 * @flags: flags associated with write
933 * @msw_ts: timestamp msw
934 * @lsw_ts: timestamp lsw
936 * Return: Will be an negative value on error or zero on success
938 int q6asm_run(struct audio_client *ac, uint32_t flags,
939 uint32_t msw_ts, uint32_t lsw_ts)
941 return __q6asm_run(ac, flags, msw_ts, lsw_ts, true);
943 EXPORT_SYMBOL_GPL(q6asm_run);
946 * q6asm_run_nowait() - start the audio client withou blocking
948 * @ac: audio client pointer
949 * @flags: flags associated with write
950 * @msw_ts: timestamp msw
951 * @lsw_ts: timestamp lsw
953 * Return: Will be an negative value on error or zero on success
955 int q6asm_run_nowait(struct audio_client *ac, uint32_t flags,
956 uint32_t msw_ts, uint32_t lsw_ts)
958 return __q6asm_run(ac, flags, msw_ts, lsw_ts, false);
960 EXPORT_SYMBOL_GPL(q6asm_run_nowait);
963 * q6asm_media_format_block_multi_ch_pcm() - setup pcm configuration
965 * @ac: audio client pointer
966 * @rate: audio sample rate
967 * @channels: number of audio channels.
968 * @channel_map: channel map pointer
969 * @bits_per_sample: bits per sample
971 * Return: Will be an negative value on error or zero on success
973 int q6asm_media_format_block_multi_ch_pcm(struct audio_client *ac,
974 uint32_t rate, uint32_t channels,
975 u8 channel_map[PCM_MAX_NUM_CHANNEL],
976 uint16_t bits_per_sample)
978 struct asm_multi_channel_pcm_fmt_blk_v2 *fmt;
984 pkt_size = APR_HDR_SIZE + sizeof(*fmt);
985 p = kzalloc(pkt_size, GFP_KERNEL);
990 fmt = p + APR_HDR_SIZE;
992 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
994 pkt->hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2;
995 fmt->fmt_blk.fmt_blk_size = sizeof(*fmt) - sizeof(fmt->fmt_blk);
996 fmt->num_channels = channels;
997 fmt->bits_per_sample = bits_per_sample;
998 fmt->sample_rate = rate;
1001 channel_mapping = fmt->channel_mapping;
1004 memcpy(channel_mapping, channel_map, PCM_MAX_NUM_CHANNEL);
1006 if (q6dsp_map_channels(channel_mapping, channels)) {
1007 dev_err(ac->dev, " map channels failed %d\n", channels);
1013 rc = q6asm_ac_send_cmd_sync(ac, pkt);
1019 EXPORT_SYMBOL_GPL(q6asm_media_format_block_multi_ch_pcm);
1022 * q6asm_enc_cfg_blk_pcm_format_support() - setup pcm configuration for capture
1024 * @ac: audio client pointer
1025 * @rate: audio sample rate
1026 * @channels: number of audio channels.
1027 * @bits_per_sample: bits per sample
1029 * Return: Will be an negative value on error or zero on success
1031 int q6asm_enc_cfg_blk_pcm_format_support(struct audio_client *ac,
1032 uint32_t rate, uint32_t channels, uint16_t bits_per_sample)
1034 struct asm_multi_channel_pcm_enc_cfg_v2 *enc_cfg;
1035 struct apr_pkt *pkt;
1036 u8 *channel_mapping;
1037 u32 frames_per_buf = 0;
1041 pkt_size = APR_HDR_SIZE + sizeof(*enc_cfg);
1042 p = kzalloc(pkt_size, GFP_KERNEL);
1047 enc_cfg = p + APR_HDR_SIZE;
1048 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
1050 pkt->hdr.opcode = ASM_STREAM_CMD_SET_ENCDEC_PARAM;
1051 enc_cfg->encdec.param_id = ASM_PARAM_ID_ENCDEC_ENC_CFG_BLK_V2;
1052 enc_cfg->encdec.param_size = sizeof(*enc_cfg) - sizeof(enc_cfg->encdec);
1053 enc_cfg->encblk.frames_per_buf = frames_per_buf;
1054 enc_cfg->encblk.enc_cfg_blk_size = enc_cfg->encdec.param_size -
1055 sizeof(struct asm_enc_cfg_blk_param_v2);
1057 enc_cfg->num_channels = channels;
1058 enc_cfg->bits_per_sample = bits_per_sample;
1059 enc_cfg->sample_rate = rate;
1060 enc_cfg->is_signed = 1;
1061 channel_mapping = enc_cfg->channel_mapping;
1063 if (q6dsp_map_channels(channel_mapping, channels)) {
1068 rc = q6asm_ac_send_cmd_sync(ac, pkt);
1073 EXPORT_SYMBOL_GPL(q6asm_enc_cfg_blk_pcm_format_support);
1076 * q6asm_read() - read data of period size from audio client
1078 * @ac: audio client pointer
1080 * Return: Will be an negative value on error or zero on success
1082 int q6asm_read(struct audio_client *ac)
1084 struct asm_data_cmd_read_v2 *read;
1085 struct audio_port_data *port;
1086 struct audio_buffer *ab;
1087 struct apr_pkt *pkt;
1088 unsigned long flags;
1093 pkt_size = APR_HDR_SIZE + sizeof(*read);
1094 p = kzalloc(pkt_size, GFP_ATOMIC);
1099 read = p + APR_HDR_SIZE;
1101 spin_lock_irqsave(&ac->lock, flags);
1102 port = &ac->port[SNDRV_PCM_STREAM_CAPTURE];
1103 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, false, ac->stream_id);
1104 ab = &port->buf[port->dsp_buf];
1105 pkt->hdr.opcode = ASM_DATA_CMD_READ_V2;
1106 read->buf_addr_lsw = lower_32_bits(ab->phys);
1107 read->buf_addr_msw = upper_32_bits(ab->phys);
1108 read->mem_map_handle = port->mem_map_handle;
1110 read->buf_size = ab->size;
1111 read->seq_id = port->dsp_buf;
1112 pkt->hdr.token = port->dsp_buf;
1116 if (port->dsp_buf >= port->num_periods)
1119 spin_unlock_irqrestore(&ac->lock, flags);
1120 rc = apr_send_pkt(ac->adev, pkt);
1124 pr_err("read op[0x%x]rc[%d]\n", pkt->hdr.opcode, rc);
1129 EXPORT_SYMBOL_GPL(q6asm_read);
1131 static int __q6asm_open_read(struct audio_client *ac,
1132 uint32_t format, uint16_t bits_per_sample)
1134 struct asm_stream_cmd_open_read_v3 *open;
1135 struct apr_pkt *pkt;
1139 pkt_size = APR_HDR_SIZE + sizeof(*open);
1140 p = kzalloc(pkt_size, GFP_KERNEL);
1145 open = p + APR_HDR_SIZE;
1147 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
1148 pkt->hdr.opcode = ASM_STREAM_CMD_OPEN_READ_V3;
1149 /* Stream prio : High, provide meta info with encoded frames */
1150 open->src_endpointype = ASM_END_POINT_DEVICE_MATRIX;
1152 open->preprocopo_id = ASM_STREAM_POSTPROC_TOPO_ID_NONE;
1153 open->bits_per_sample = bits_per_sample;
1154 open->mode_flags = 0x0;
1156 open->mode_flags |= ASM_LEGACY_STREAM_SESSION <<
1157 ASM_SHIFT_STREAM_PERF_MODE_FLAG_IN_OPEN_READ;
1160 case FORMAT_LINEAR_PCM:
1161 open->mode_flags |= 0x00;
1162 open->enc_cfg_id = ASM_MEDIA_FMT_MULTI_CHANNEL_PCM_V2;
1165 pr_err("Invalid format[%d]\n", format);
1168 rc = q6asm_ac_send_cmd_sync(ac, pkt);
1175 * q6asm_open_read() - Open audio client for reading
1177 * @ac: audio client pointer
1178 * @format: audio sample format
1179 * @bits_per_sample: bits per sample
1181 * Return: Will be an negative value on error or zero on success
1183 int q6asm_open_read(struct audio_client *ac, uint32_t format,
1184 uint16_t bits_per_sample)
1186 return __q6asm_open_read(ac, format, bits_per_sample);
1188 EXPORT_SYMBOL_GPL(q6asm_open_read);
1191 * q6asm_write_async() - non blocking write
1193 * @ac: audio client pointer
1194 * @len: lenght in bytes
1195 * @msw_ts: timestamp msw
1196 * @lsw_ts: timestamp lsw
1197 * @wflags: flags associated with write
1199 * Return: Will be an negative value on error or zero on success
1201 int q6asm_write_async(struct audio_client *ac, uint32_t len, uint32_t msw_ts,
1202 uint32_t lsw_ts, uint32_t wflags)
1204 struct asm_data_cmd_write_v2 *write;
1205 struct audio_port_data *port;
1206 struct audio_buffer *ab;
1207 unsigned long flags;
1208 struct apr_pkt *pkt;
1213 pkt_size = APR_HDR_SIZE + sizeof(*write);
1214 p = kzalloc(pkt_size, GFP_ATOMIC);
1219 write = p + APR_HDR_SIZE;
1221 spin_lock_irqsave(&ac->lock, flags);
1222 port = &ac->port[SNDRV_PCM_STREAM_PLAYBACK];
1223 q6asm_add_hdr(ac, &pkt->hdr, pkt_size, false, ac->stream_id);
1225 ab = &port->buf[port->dsp_buf];
1226 pkt->hdr.token = port->dsp_buf;
1227 pkt->hdr.opcode = ASM_DATA_CMD_WRITE_V2;
1228 write->buf_addr_lsw = lower_32_bits(ab->phys);
1229 write->buf_addr_msw = upper_32_bits(ab->phys);
1230 write->buf_size = len;
1231 write->seq_id = port->dsp_buf;
1232 write->timestamp_lsw = lsw_ts;
1233 write->timestamp_msw = msw_ts;
1234 write->mem_map_handle =
1235 ac->port[SNDRV_PCM_STREAM_PLAYBACK].mem_map_handle;
1237 if (wflags == NO_TIMESTAMP)
1238 write->flags = (wflags & 0x800000FF);
1240 write->flags = (0x80000000 | wflags);
1244 if (port->dsp_buf >= port->num_periods)
1247 spin_unlock_irqrestore(&ac->lock, flags);
1248 rc = apr_send_pkt(ac->adev, pkt);
1255 EXPORT_SYMBOL_GPL(q6asm_write_async);
1257 static void q6asm_reset_buf_state(struct audio_client *ac)
1259 struct audio_port_data *port = NULL;
1260 unsigned long flags;
1262 spin_lock_irqsave(&ac->lock, flags);
1263 port = &ac->port[SNDRV_PCM_STREAM_PLAYBACK];
1265 port = &ac->port[SNDRV_PCM_STREAM_CAPTURE];
1267 spin_unlock_irqrestore(&ac->lock, flags);
1270 static int __q6asm_cmd(struct audio_client *ac, int cmd, bool wait)
1272 int stream_id = ac->stream_id;
1276 q6asm_add_hdr(ac, &pkt.hdr, APR_HDR_SIZE, true, stream_id);
1280 pkt.hdr.opcode = ASM_SESSION_CMD_PAUSE;
1283 pkt.hdr.opcode = ASM_SESSION_CMD_SUSPEND;
1286 pkt.hdr.opcode = ASM_STREAM_CMD_FLUSH;
1289 pkt.hdr.opcode = ASM_STREAM_CMD_FLUSH_READBUFS;
1292 pkt.hdr.opcode = ASM_DATA_CMD_EOS;
1295 pkt.hdr.opcode = ASM_STREAM_CMD_CLOSE;
1302 rc = q6asm_ac_send_cmd_sync(ac, &pkt);
1304 return apr_send_pkt(ac->adev, &pkt);
1309 if (cmd == CMD_FLUSH)
1310 q6asm_reset_buf_state(ac);
1316 * q6asm_cmd() - run cmd on audio client
1318 * @ac: audio client pointer
1319 * @cmd: command to run on audio client.
1321 * Return: Will be an negative value on error or zero on success
1323 int q6asm_cmd(struct audio_client *ac, int cmd)
1325 return __q6asm_cmd(ac, cmd, true);
1327 EXPORT_SYMBOL_GPL(q6asm_cmd);
1330 * q6asm_cmd_nowait() - non blocking, run cmd on audio client
1332 * @ac: audio client pointer
1333 * @cmd: command to run on audio client.
1335 * Return: Will be an negative value on error or zero on success
1337 int q6asm_cmd_nowait(struct audio_client *ac, int cmd)
1339 return __q6asm_cmd(ac, cmd, false);
1341 EXPORT_SYMBOL_GPL(q6asm_cmd_nowait);
1343 static int q6asm_probe(struct apr_device *adev)
1345 struct device *dev = &adev->dev;
1346 struct q6asm *q6asm;
1348 q6asm = devm_kzalloc(dev, sizeof(*q6asm), GFP_KERNEL);
1352 q6core_get_svc_api_info(adev->svc_id, &q6asm->ainfo);
1356 init_waitqueue_head(&q6asm->mem_wait);
1357 spin_lock_init(&q6asm->slock);
1358 dev_set_drvdata(dev, q6asm);
1360 return of_platform_populate(dev->of_node, NULL, NULL, dev);
1363 static int q6asm_remove(struct apr_device *adev)
1365 of_platform_depopulate(&adev->dev);
1369 static const struct of_device_id q6asm_device_id[] = {
1370 { .compatible = "qcom,q6asm" },
1373 MODULE_DEVICE_TABLE(of, q6asm_device_id);
1375 static struct apr_driver qcom_q6asm_driver = {
1376 .probe = q6asm_probe,
1377 .remove = q6asm_remove,
1378 .callback = q6asm_srvc_callback,
1380 .name = "qcom-q6asm",
1381 .of_match_table = of_match_ptr(q6asm_device_id),
1385 module_apr_driver(qcom_q6asm_driver);
1386 MODULE_DESCRIPTION("Q6 Audio Stream Manager driver");
1387 MODULE_LICENSE("GPL v2");