| /* Copyright (c) 2012-2014, The Linux Foundation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 and |
| * only version 2 as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| */ |
| |
| |
| #include <linux/init.h> |
| #include <linux/err.h> |
| #include <linux/module.h> |
| #include <linux/moduleparam.h> |
| #include <linux/time.h> |
| #include <linux/wait.h> |
| #include <linux/platform_device.h> |
| #include <linux/slab.h> |
| #include <sound/core.h> |
| #include <sound/soc.h> |
| #include <sound/soc-dapm.h> |
| #include <sound/pcm.h> |
| #include <sound/initval.h> |
| #include <sound/control.h> |
| #include <sound/q6audio-v2.h> |
| #include <asm/dma.h> |
| #include <linux/dma-mapping.h> |
| #include <linux/msm_audio_ion.h> |
| |
| #include <linux/of_device.h> |
| #include <sound/pcm_params.h> |
| |
| #include "msm-pcm-q6-v2.h" |
| #include "msm-pcm-routing-v2.h" |
| |
| static struct audio_locks the_locks; |
| |
| struct snd_msm { |
| struct snd_card *card; |
| struct snd_pcm *pcm; |
| }; |
| |
| #define PLAYBACK_MIN_NUM_PERIODS 2 |
| #define PLAYBACK_MAX_NUM_PERIODS 8 |
| #define PLAYBACK_MAX_PERIOD_SIZE 12288 |
| #define PLAYBACK_MIN_PERIOD_SIZE 128 |
| #define CAPTURE_MIN_NUM_PERIODS 2 |
| #define CAPTURE_MAX_NUM_PERIODS 8 |
| #define CAPTURE_MAX_PERIOD_SIZE 4096 |
| #define CAPTURE_MIN_PERIOD_SIZE 320 |
| |
| static struct snd_pcm_hardware msm_pcm_hardware_capture = { |
| .info = (SNDRV_PCM_INFO_MMAP | |
| SNDRV_PCM_INFO_BLOCK_TRANSFER | |
| SNDRV_PCM_INFO_MMAP_VALID | |
| SNDRV_PCM_INFO_INTERLEAVED | |
| SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME), |
| .formats = (SNDRV_PCM_FMTBIT_S16_LE | |
| SNDRV_PCM_FMTBIT_S24_LE), |
| .rates = SNDRV_PCM_RATE_8000_48000, |
| .rate_min = 8000, |
| .rate_max = 48000, |
| .channels_min = 1, |
| .channels_max = 4, |
| .buffer_bytes_max = CAPTURE_MAX_NUM_PERIODS * |
| CAPTURE_MAX_PERIOD_SIZE, |
| .period_bytes_min = CAPTURE_MIN_PERIOD_SIZE, |
| .period_bytes_max = CAPTURE_MAX_PERIOD_SIZE, |
| .periods_min = CAPTURE_MIN_NUM_PERIODS, |
| .periods_max = CAPTURE_MAX_NUM_PERIODS, |
| .fifo_size = 0, |
| }; |
| |
| static struct snd_pcm_hardware msm_pcm_hardware_playback = { |
| .info = (SNDRV_PCM_INFO_MMAP | |
| SNDRV_PCM_INFO_BLOCK_TRANSFER | |
| SNDRV_PCM_INFO_MMAP_VALID | |
| SNDRV_PCM_INFO_INTERLEAVED | |
| SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME), |
| .formats = (SNDRV_PCM_FMTBIT_S16_LE | |
| SNDRV_PCM_FMTBIT_S24_LE), |
| .rates = SNDRV_PCM_RATE_8000_192000, |
| .rate_min = 8000, |
| .rate_max = 192000, |
| .channels_min = 1, |
| .channels_max = 8, |
| .buffer_bytes_max = PLAYBACK_MAX_NUM_PERIODS * |
| PLAYBACK_MAX_PERIOD_SIZE, |
| .period_bytes_min = PLAYBACK_MIN_PERIOD_SIZE, |
| .period_bytes_max = PLAYBACK_MAX_PERIOD_SIZE, |
| .periods_min = PLAYBACK_MIN_NUM_PERIODS, |
| .periods_max = PLAYBACK_MAX_NUM_PERIODS, |
| .fifo_size = 0, |
| }; |
| |
| /* Conventional and unconventional sample rate supported */ |
| static unsigned int supported_sample_rates[] = { |
| 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, |
| 88200, 96000, 176400, 192000 |
| }; |
| |
| static uint32_t in_frame_info[CAPTURE_MAX_NUM_PERIODS][2]; |
| |
| static struct snd_pcm_hw_constraint_list constraints_sample_rates = { |
| .count = ARRAY_SIZE(supported_sample_rates), |
| .list = supported_sample_rates, |
| .mask = 0, |
| }; |
| |
| static void msm_pcm_route_event_handler(enum msm_pcm_routing_event event, |
| void *priv_data) |
| { |
| struct msm_audio *prtd = priv_data; |
| |
| BUG_ON(!prtd); |
| |
| pr_debug("%s: event %x\n", __func__, event); |
| |
| switch (event) { |
| case MSM_PCM_RT_EVT_BUF_RECFG: |
| q6asm_cmd(prtd->audio_client, CMD_PAUSE); |
| q6asm_cmd(prtd->audio_client, CMD_FLUSH); |
| q6asm_run(prtd->audio_client, 0, 0, 0); |
| default: |
| break; |
| } |
| } |
| |
| static void event_handler(uint32_t opcode, |
| uint32_t token, uint32_t *payload, void *priv) |
| { |
| struct msm_audio *prtd = priv; |
| struct snd_pcm_substream *substream = prtd->substream; |
| uint32_t *ptrmem = (uint32_t *)payload; |
| uint32_t idx = 0; |
| uint32_t size = 0; |
| |
| switch (opcode) { |
| case ASM_DATA_EVENT_WRITE_DONE_V2: { |
| pr_debug("ASM_DATA_EVENT_WRITE_DONE_V2\n"); |
| pr_debug("Buffer Consumed = 0x%08x\n", *ptrmem); |
| prtd->pcm_irq_pos += prtd->pcm_count; |
| if (atomic_read(&prtd->start)) |
| snd_pcm_period_elapsed(substream); |
| atomic_inc(&prtd->out_count); |
| wake_up(&the_locks.write_wait); |
| if (!atomic_read(&prtd->start)) |
| break; |
| if (!prtd->mmap_flag) |
| break; |
| if (q6asm_is_cpu_buf_avail_nolock(IN, |
| prtd->audio_client, |
| &size, &idx)) { |
| pr_debug("%s:writing %d bytes of buffer to dsp 2\n", |
| __func__, prtd->pcm_count); |
| q6asm_write_nolock(prtd->audio_client, |
| prtd->pcm_count, 0, 0, NO_TIMESTAMP); |
| } |
| break; |
| } |
| case ASM_DATA_EVENT_RENDERED_EOS: |
| pr_debug("ASM_DATA_EVENT_RENDERED_EOS\n"); |
| clear_bit(CMD_EOS, &prtd->cmd_pending); |
| wake_up(&the_locks.eos_wait); |
| break; |
| case ASM_DATA_EVENT_READ_DONE_V2: { |
| pr_debug("ASM_DATA_EVENT_READ_DONE_V2\n"); |
| pr_debug("token = 0x%08x\n", token); |
| in_frame_info[token][0] = payload[4]; |
| in_frame_info[token][1] = payload[5]; |
| /* assume data size = 0 during flushing */ |
| if (in_frame_info[token][0]) { |
| prtd->pcm_irq_pos += in_frame_info[token][0]; |
| pr_debug("pcm_irq_pos=%d\n", prtd->pcm_irq_pos); |
| if (atomic_read(&prtd->start)) |
| snd_pcm_period_elapsed(substream); |
| if (atomic_read(&prtd->in_count) <= prtd->periods) |
| atomic_inc(&prtd->in_count); |
| wake_up(&the_locks.read_wait); |
| if (prtd->mmap_flag && |
| q6asm_is_cpu_buf_avail_nolock(OUT, |
| prtd->audio_client, |
| &size, &idx)) |
| q6asm_read_nolock(prtd->audio_client); |
| } else { |
| pr_debug("%s: reclaim flushed buf in_count %x\n", |
| __func__, atomic_read(&prtd->in_count)); |
| prtd->pcm_irq_pos += prtd->pcm_count; |
| atomic_inc(&prtd->in_count); |
| if (atomic_read(&prtd->in_count) == prtd->periods) { |
| pr_info("%s: reclaimed all bufs\n", __func__); |
| if (atomic_read(&prtd->start)) |
| snd_pcm_period_elapsed(substream); |
| wake_up(&the_locks.read_wait); |
| } |
| } |
| break; |
| } |
| case APR_BASIC_RSP_RESULT: { |
| switch (payload[0]) { |
| case ASM_SESSION_CMD_RUN_V2: |
| if (substream->stream |
| != SNDRV_PCM_STREAM_PLAYBACK) { |
| atomic_set(&prtd->start, 1); |
| break; |
| } |
| if (prtd->mmap_flag) { |
| pr_debug("%s:writing %d bytes of buffer to dsp\n", |
| __func__, |
| prtd->pcm_count); |
| q6asm_write_nolock(prtd->audio_client, |
| prtd->pcm_count, |
| 0, 0, NO_TIMESTAMP); |
| } else { |
| while (atomic_read(&prtd->out_needed)) { |
| pr_debug("%s:writing %d bytes of buffer to dsp\n", |
| __func__, |
| prtd->pcm_count); |
| q6asm_write_nolock(prtd->audio_client, |
| prtd->pcm_count, |
| 0, 0, NO_TIMESTAMP); |
| atomic_dec(&prtd->out_needed); |
| wake_up(&the_locks.write_wait); |
| }; |
| } |
| atomic_set(&prtd->start, 1); |
| break; |
| default: |
| pr_debug("%s:Payload = [0x%x]stat[0x%x]\n", |
| __func__, payload[0], payload[1]); |
| break; |
| } |
| } |
| break; |
| default: |
| pr_debug("Not Supported Event opcode[0x%x]\n", opcode); |
| break; |
| } |
| } |
| |
| static int msm_pcm_playback_prepare(struct snd_pcm_substream *substream) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct msm_audio *prtd = runtime->private_data; |
| int ret; |
| uint16_t bits_per_sample = 16; |
| |
| pr_debug("%s\n", __func__); |
| prtd->pcm_size = snd_pcm_lib_buffer_bytes(substream); |
| prtd->pcm_count = snd_pcm_lib_period_bytes(substream); |
| prtd->pcm_irq_pos = 0; |
| /* rate and channels are sent to audio driver */ |
| prtd->samp_rate = runtime->rate; |
| prtd->channel_mode = runtime->channels; |
| if (prtd->enabled) |
| return 0; |
| |
| switch (runtime->format) { |
| case SNDRV_PCM_FORMAT_S16_LE: |
| bits_per_sample = 16; |
| break; |
| case SNDRV_PCM_FORMAT_S24_LE: |
| bits_per_sample = 24; |
| break; |
| } |
| |
| ret = q6asm_media_format_block_multi_ch_pcm_v2( |
| prtd->audio_client, runtime->rate, |
| runtime->channels, !prtd->set_channel_map, |
| prtd->channel_map, bits_per_sample); |
| if (ret < 0) |
| pr_info("%s: CMD Format block failed\n", __func__); |
| |
| atomic_set(&prtd->out_count, runtime->periods); |
| |
| prtd->enabled = 1; |
| prtd->cmd_pending = 0; |
| prtd->cmd_interrupt = 0; |
| |
| return 0; |
| } |
| |
| static int msm_pcm_capture_prepare(struct snd_pcm_substream *substream) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct msm_audio *prtd = runtime->private_data; |
| int ret = 0; |
| int i = 0; |
| uint16_t bits_per_sample = 16; |
| |
| pr_debug("%s\n", __func__); |
| prtd->pcm_size = snd_pcm_lib_buffer_bytes(substream); |
| prtd->pcm_count = snd_pcm_lib_period_bytes(substream); |
| prtd->pcm_irq_pos = 0; |
| |
| /* rate and channels are sent to audio driver */ |
| prtd->samp_rate = runtime->rate; |
| prtd->channel_mode = runtime->channels; |
| |
| if (prtd->enabled) |
| return 0; |
| |
| switch (runtime->format) { |
| case SNDRV_PCM_FORMAT_S16_LE: |
| bits_per_sample = 16; |
| break; |
| case SNDRV_PCM_FORMAT_S24_LE: |
| bits_per_sample = 24; |
| break; |
| } |
| pr_debug("Samp_rate = %d\n", prtd->samp_rate); |
| pr_debug("Channel = %d\n", prtd->channel_mode); |
| ret = q6asm_enc_cfg_blk_pcm_format_support(prtd->audio_client, |
| prtd->samp_rate, prtd->channel_mode, |
| bits_per_sample); |
| if (ret < 0) |
| pr_debug("%s: cmd cfg pcm was block failed", __func__); |
| |
| for (i = 0; i < runtime->periods; i++) |
| q6asm_read(prtd->audio_client); |
| prtd->periods = runtime->periods; |
| |
| prtd->enabled = 1; |
| |
| return ret; |
| } |
| |
| static int msm_pcm_trigger(struct snd_pcm_substream *substream, int cmd) |
| { |
| int ret = 0; |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct msm_audio *prtd = runtime->private_data; |
| |
| switch (cmd) { |
| case SNDRV_PCM_TRIGGER_START: |
| case SNDRV_PCM_TRIGGER_RESUME: |
| case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: |
| pr_debug("%s: Trigger start\n", __func__); |
| ret = q6asm_run_nowait(prtd->audio_client, 0, 0, 0); |
| break; |
| case SNDRV_PCM_TRIGGER_STOP: |
| pr_debug("SNDRV_PCM_TRIGGER_STOP\n"); |
| atomic_set(&prtd->start, 0); |
| if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) |
| break; |
| /* pending CMD_EOS isn't expected */ |
| WARN_ON_ONCE(test_bit(CMD_EOS, &prtd->cmd_pending)); |
| set_bit(CMD_EOS, &prtd->cmd_pending); |
| ret = q6asm_cmd_nowait(prtd->audio_client, CMD_EOS); |
| if (ret) |
| clear_bit(CMD_EOS, &prtd->cmd_pending); |
| break; |
| case SNDRV_PCM_TRIGGER_SUSPEND: |
| case SNDRV_PCM_TRIGGER_PAUSE_PUSH: |
| pr_debug("SNDRV_PCM_TRIGGER_PAUSE\n"); |
| ret = q6asm_cmd_nowait(prtd->audio_client, CMD_PAUSE); |
| atomic_set(&prtd->start, 0); |
| break; |
| default: |
| ret = -EINVAL; |
| break; |
| } |
| |
| return ret; |
| } |
| |
| static int msm_pcm_open(struct snd_pcm_substream *substream) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct msm_audio *prtd; |
| int ret = 0; |
| |
| prtd = kzalloc(sizeof(struct msm_audio), GFP_KERNEL); |
| if (prtd == NULL) { |
| pr_err("Failed to allocate memory for msm_audio\n"); |
| return -ENOMEM; |
| } |
| prtd->substream = substream; |
| prtd->audio_client = q6asm_audio_client_alloc( |
| (app_cb)event_handler, prtd); |
| if (!prtd->audio_client) { |
| pr_info("%s: Could not allocate memory\n", __func__); |
| kfree(prtd); |
| return -ENOMEM; |
| } |
| |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
| runtime->hw = msm_pcm_hardware_playback; |
| |
| /* Capture path */ |
| else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) |
| runtime->hw = msm_pcm_hardware_capture; |
| else { |
| pr_err("Invalid Stream type %d\n", substream->stream); |
| return -EINVAL; |
| } |
| |
| ret = snd_pcm_hw_constraint_list(runtime, 0, |
| SNDRV_PCM_HW_PARAM_RATE, |
| &constraints_sample_rates); |
| if (ret < 0) |
| pr_info("snd_pcm_hw_constraint_list failed\n"); |
| /* Ensure that buffer size is a multiple of period size */ |
| ret = snd_pcm_hw_constraint_integer(runtime, |
| SNDRV_PCM_HW_PARAM_PERIODS); |
| if (ret < 0) |
| pr_info("snd_pcm_hw_constraint_integer failed\n"); |
| |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { |
| ret = snd_pcm_hw_constraint_minmax(runtime, |
| SNDRV_PCM_HW_PARAM_BUFFER_BYTES, |
| PLAYBACK_MIN_NUM_PERIODS * PLAYBACK_MIN_PERIOD_SIZE, |
| PLAYBACK_MAX_NUM_PERIODS * PLAYBACK_MAX_PERIOD_SIZE); |
| if (ret < 0) { |
| pr_err("constraint for buffer bytes min max ret = %d\n", |
| ret); |
| } |
| } |
| |
| if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { |
| ret = snd_pcm_hw_constraint_minmax(runtime, |
| SNDRV_PCM_HW_PARAM_BUFFER_BYTES, |
| CAPTURE_MIN_NUM_PERIODS * CAPTURE_MIN_PERIOD_SIZE, |
| CAPTURE_MAX_NUM_PERIODS * CAPTURE_MAX_PERIOD_SIZE); |
| if (ret < 0) { |
| pr_err("constraint for buffer bytes min max ret = %d\n", |
| ret); |
| } |
| } |
| ret = snd_pcm_hw_constraint_step(runtime, 0, |
| SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 32); |
| if (ret < 0) { |
| pr_err("constraint for period bytes step ret = %d\n", |
| ret); |
| } |
| ret = snd_pcm_hw_constraint_step(runtime, 0, |
| SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 32); |
| if (ret < 0) { |
| pr_err("constraint for buffer bytes step ret = %d\n", |
| ret); |
| } |
| |
| prtd->dsp_cnt = 0; |
| prtd->set_channel_map = false; |
| runtime->private_data = prtd; |
| |
| return 0; |
| } |
| |
| static int msm_pcm_playback_copy(struct snd_pcm_substream *substream, int a, |
| snd_pcm_uframes_t hwoff, void __user *buf, snd_pcm_uframes_t frames) |
| { |
| int ret = 0; |
| int fbytes = 0; |
| int xfer = 0; |
| char *bufptr = NULL; |
| void *data = NULL; |
| uint32_t idx = 0; |
| uint32_t size = 0; |
| |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct msm_audio *prtd = runtime->private_data; |
| |
| fbytes = frames_to_bytes(runtime, frames); |
| pr_debug("%s: prtd->out_count = %d\n", |
| __func__, atomic_read(&prtd->out_count)); |
| ret = wait_event_timeout(the_locks.write_wait, |
| (atomic_read(&prtd->out_count)), 5 * HZ); |
| if (!ret) { |
| pr_err("%s: wait_event_timeout failed\n", __func__); |
| goto fail; |
| } |
| |
| if (!atomic_read(&prtd->out_count)) { |
| pr_err("%s: pcm stopped out_count 0\n", __func__); |
| return 0; |
| } |
| |
| data = q6asm_is_cpu_buf_avail(IN, prtd->audio_client, &size, &idx); |
| if (size < fbytes) { |
| fbytes = size; |
| } |
| bufptr = data; |
| if (bufptr) { |
| pr_debug("%s:fbytes =%d: xfer=%d size=%d\n", |
| __func__, fbytes, xfer, size); |
| xfer = fbytes; |
| if (copy_from_user(bufptr, buf, xfer)) { |
| ret = -EFAULT; |
| goto fail; |
| } |
| buf += xfer; |
| fbytes -= xfer; |
| pr_debug("%s:fbytes = %d: xfer=%d\n", __func__, fbytes, xfer); |
| if (atomic_read(&prtd->start)) { |
| pr_debug("%s:writing %d bytes of buffer to dsp\n", |
| __func__, xfer); |
| ret = q6asm_write(prtd->audio_client, xfer, |
| 0, 0, NO_TIMESTAMP); |
| if (ret < 0) { |
| ret = -EFAULT; |
| goto fail; |
| } |
| } else |
| atomic_inc(&prtd->out_needed); |
| atomic_dec(&prtd->out_count); |
| } |
| fail: |
| return ret; |
| } |
| |
| static int msm_pcm_playback_close(struct snd_pcm_substream *substream) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct snd_soc_pcm_runtime *soc_prtd = substream->private_data; |
| struct msm_audio *prtd = runtime->private_data; |
| int dir = 0; |
| int ret = 0; |
| |
| pr_debug("%s: cmd_pending 0x%lx\n", __func__, prtd->cmd_pending); |
| |
| if (prtd->audio_client) { |
| dir = IN; |
| ret = wait_event_timeout(the_locks.eos_wait, |
| !test_bit(CMD_EOS, &prtd->cmd_pending), |
| 5 * HZ); |
| if (!ret) |
| pr_err("%s: CMD_EOS failed, cmd_pending 0x%lx\n", |
| __func__, prtd->cmd_pending); |
| q6asm_cmd(prtd->audio_client, CMD_CLOSE); |
| q6asm_audio_client_buf_free_contiguous(dir, |
| prtd->audio_client); |
| q6asm_audio_client_free(prtd->audio_client); |
| } |
| msm_pcm_routing_dereg_phy_stream(soc_prtd->dai_link->be_id, |
| SNDRV_PCM_STREAM_PLAYBACK); |
| kfree(prtd); |
| return 0; |
| } |
| |
| static int msm_pcm_capture_copy(struct snd_pcm_substream *substream, |
| int channel, snd_pcm_uframes_t hwoff, void __user *buf, |
| snd_pcm_uframes_t frames) |
| { |
| int ret = 0; |
| int fbytes = 0; |
| int xfer; |
| char *bufptr; |
| void *data = NULL; |
| static uint32_t idx; |
| static uint32_t size; |
| uint32_t offset = 0; |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct msm_audio *prtd = substream->runtime->private_data; |
| |
| |
| pr_debug("%s\n", __func__); |
| fbytes = frames_to_bytes(runtime, frames); |
| |
| pr_debug("appl_ptr %d\n", (int)runtime->control->appl_ptr); |
| pr_debug("hw_ptr %d\n", (int)runtime->status->hw_ptr); |
| pr_debug("avail_min %d\n", (int)runtime->control->avail_min); |
| |
| ret = wait_event_timeout(the_locks.read_wait, |
| (atomic_read(&prtd->in_count)), 5 * HZ); |
| if (!ret) { |
| pr_debug("%s: wait_event_timeout failed\n", __func__); |
| goto fail; |
| } |
| if (!atomic_read(&prtd->in_count)) { |
| pr_debug("%s: pcm stopped in_count 0\n", __func__); |
| return 0; |
| } |
| pr_debug("Checking if valid buffer is available...%08x\n", |
| (unsigned int) data); |
| data = q6asm_is_cpu_buf_avail(OUT, prtd->audio_client, &size, &idx); |
| bufptr = data; |
| pr_debug("Size = %d\n", size); |
| pr_debug("fbytes = %d\n", fbytes); |
| pr_debug("idx = %d\n", idx); |
| if (bufptr) { |
| xfer = fbytes; |
| if (xfer > size) |
| xfer = size; |
| offset = in_frame_info[idx][1]; |
| pr_debug("Offset value = %d\n", offset); |
| if (copy_to_user(buf, bufptr+offset, xfer)) { |
| pr_err("Failed to copy buf to user\n"); |
| ret = -EFAULT; |
| goto fail; |
| } |
| fbytes -= xfer; |
| size -= xfer; |
| in_frame_info[idx][1] += xfer; |
| pr_debug("%s:fbytes = %d: size=%d: xfer=%d\n", |
| __func__, fbytes, size, xfer); |
| pr_debug(" Sending next buffer to dsp\n"); |
| memset(&in_frame_info[idx], 0, |
| sizeof(uint32_t) * 2); |
| atomic_dec(&prtd->in_count); |
| ret = q6asm_read(prtd->audio_client); |
| if (ret < 0) { |
| pr_err("q6asm read failed\n"); |
| ret = -EFAULT; |
| goto fail; |
| } |
| } else |
| pr_err("No valid buffer\n"); |
| |
| pr_debug("Returning from capture_copy... %d\n", ret); |
| fail: |
| return ret; |
| } |
| |
| static int msm_pcm_capture_close(struct snd_pcm_substream *substream) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct snd_soc_pcm_runtime *soc_prtd = substream->private_data; |
| struct msm_audio *prtd = runtime->private_data; |
| int dir = OUT; |
| |
| pr_debug("%s\n", __func__); |
| if (prtd->audio_client) { |
| q6asm_cmd(prtd->audio_client, CMD_CLOSE); |
| q6asm_audio_client_buf_free_contiguous(dir, |
| prtd->audio_client); |
| q6asm_audio_client_free(prtd->audio_client); |
| } |
| |
| msm_pcm_routing_dereg_phy_stream(soc_prtd->dai_link->be_id, |
| SNDRV_PCM_STREAM_CAPTURE); |
| kfree(prtd); |
| |
| return 0; |
| } |
| |
| static int msm_pcm_copy(struct snd_pcm_substream *substream, int a, |
| snd_pcm_uframes_t hwoff, void __user *buf, snd_pcm_uframes_t frames) |
| { |
| int ret = 0; |
| |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
| ret = msm_pcm_playback_copy(substream, a, hwoff, buf, frames); |
| else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) |
| ret = msm_pcm_capture_copy(substream, a, hwoff, buf, frames); |
| return ret; |
| } |
| |
| static int msm_pcm_close(struct snd_pcm_substream *substream) |
| { |
| int ret = 0; |
| |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
| ret = msm_pcm_playback_close(substream); |
| else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) |
| ret = msm_pcm_capture_close(substream); |
| return ret; |
| } |
| static int msm_pcm_prepare(struct snd_pcm_substream *substream) |
| { |
| int ret = 0; |
| |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
| ret = msm_pcm_playback_prepare(substream); |
| else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) |
| ret = msm_pcm_capture_prepare(substream); |
| return ret; |
| } |
| |
| static snd_pcm_uframes_t msm_pcm_pointer(struct snd_pcm_substream *substream) |
| { |
| |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct msm_audio *prtd = runtime->private_data; |
| |
| if (prtd->pcm_irq_pos >= prtd->pcm_size) |
| prtd->pcm_irq_pos = 0; |
| |
| pr_debug("pcm_irq_pos = %d\n", prtd->pcm_irq_pos); |
| return bytes_to_frames(runtime, (prtd->pcm_irq_pos)); |
| } |
| |
| static int msm_pcm_mmap(struct snd_pcm_substream *substream, |
| struct vm_area_struct *vma) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct msm_audio *prtd = runtime->private_data; |
| struct audio_client *ac = prtd->audio_client; |
| struct audio_port_data *apd = ac->port; |
| struct audio_buffer *ab; |
| int dir = -1; |
| |
| prtd->mmap_flag = 1; |
| |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
| dir = IN; |
| else |
| dir = OUT; |
| ab = &(apd[dir].buf[0]); |
| |
| return msm_audio_ion_mmap(ab, vma); |
| } |
| |
| static int msm_pcm_hw_params(struct snd_pcm_substream *substream, |
| struct snd_pcm_hw_params *params) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct msm_audio *prtd = runtime->private_data; |
| struct snd_dma_buffer *dma_buf = &substream->dma_buffer; |
| struct snd_soc_pcm_runtime *soc_prtd = substream->private_data; |
| struct audio_buffer *buf; |
| int dir, ret; |
| struct msm_plat_data *pdata; |
| uint16_t bits_per_sample = 16; |
| struct msm_pcm_routing_evt event; |
| |
| pdata = (struct msm_plat_data *) |
| dev_get_drvdata(soc_prtd->platform->dev); |
| if (!pdata) { |
| pr_err("%s: platform data not populated\n", __func__); |
| return -EINVAL; |
| } |
| |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
| dir = IN; |
| else |
| dir = OUT; |
| |
| prtd->audio_client->perf_mode = pdata->perf_mode; |
| pr_debug("%s: perf: %x\n", __func__, pdata->perf_mode); |
| /* Playback Path */ |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { |
| if (params_format(params) == SNDRV_PCM_FORMAT_S24_LE) |
| bits_per_sample = 24; |
| |
| ret = q6asm_open_write_v2(prtd->audio_client, |
| FORMAT_LINEAR_PCM, bits_per_sample); |
| if (ret < 0) { |
| pr_err("%s: q6asm_open_write_v2 failed\n", __func__); |
| q6asm_audio_client_free(prtd->audio_client); |
| prtd->audio_client = NULL; |
| return -ENOMEM; |
| } |
| |
| pr_debug("%s: session ID %d\n", __func__, |
| prtd->audio_client->session); |
| prtd->session_id = prtd->audio_client->session; |
| msm_pcm_routing_reg_phy_stream(soc_prtd->dai_link->be_id, |
| prtd->audio_client->perf_mode, |
| prtd->session_id, substream->stream); |
| } |
| |
| /* Capture Path */ |
| if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { |
| if (params_format(params) == SNDRV_PCM_FORMAT_S24_LE) |
| bits_per_sample = 24; |
| |
| pr_debug("%s Opening %d-ch PCM read stream\n", |
| __func__, params_channels(params)); |
| ret = q6asm_open_read_v2(prtd->audio_client, FORMAT_LINEAR_PCM, |
| bits_per_sample); |
| if (ret < 0) { |
| pr_err("%s: q6asm_open_read failed\n", __func__); |
| q6asm_audio_client_free(prtd->audio_client); |
| prtd->audio_client = NULL; |
| return -ENOMEM; |
| } |
| |
| pr_debug("%s: session ID %d\n", |
| __func__, prtd->audio_client->session); |
| prtd->session_id = prtd->audio_client->session; |
| event.event_func = msm_pcm_route_event_handler; |
| event.priv_data = (void *) prtd; |
| msm_pcm_routing_reg_phy_stream_v2(soc_prtd->dai_link->be_id, |
| prtd->audio_client->perf_mode, |
| prtd->session_id, substream->stream, |
| event); |
| } |
| |
| ret = q6asm_audio_client_buf_alloc_contiguous(dir, |
| prtd->audio_client, |
| (params_buffer_bytes(params) / params_periods(params)), |
| params_periods(params)); |
| if (ret < 0) { |
| pr_err("Audio Start: Buffer Allocation failed rc = %d\n", |
| ret); |
| return -ENOMEM; |
| } |
| buf = prtd->audio_client->port[dir].buf; |
| if (buf == NULL || buf[0].data == NULL) |
| return -ENOMEM; |
| |
| pr_debug("%s:buf = %p\n", __func__, buf); |
| dma_buf->dev.type = SNDRV_DMA_TYPE_DEV; |
| dma_buf->dev.dev = substream->pcm->card->dev; |
| dma_buf->private_data = NULL; |
| dma_buf->area = buf[0].data; |
| dma_buf->addr = buf[0].phys; |
| dma_buf->bytes = params_buffer_bytes(params); |
| if (!dma_buf->area) |
| return -ENOMEM; |
| |
| snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer); |
| return 0; |
| } |
| |
| static struct snd_pcm_ops msm_pcm_ops = { |
| .open = msm_pcm_open, |
| .copy = msm_pcm_copy, |
| .hw_params = msm_pcm_hw_params, |
| .close = msm_pcm_close, |
| .ioctl = snd_pcm_lib_ioctl, |
| .prepare = msm_pcm_prepare, |
| .trigger = msm_pcm_trigger, |
| .pointer = msm_pcm_pointer, |
| .mmap = msm_pcm_mmap, |
| }; |
| |
| static int msm_pcm_chmap_ctl_put(struct snd_kcontrol *kcontrol, |
| struct snd_ctl_elem_value *ucontrol) |
| { |
| int i; |
| struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol); |
| unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); |
| struct snd_pcm_substream *substream; |
| struct msm_audio *prtd; |
| |
| pr_debug("%s", __func__); |
| substream = snd_pcm_chmap_substream(info, idx); |
| if (!substream) |
| return -ENODEV; |
| if (!substream->runtime) |
| return 0; |
| |
| prtd = substream->runtime->private_data; |
| if (prtd) { |
| prtd->set_channel_map = true; |
| for (i = 0; i < PCM_FORMAT_MAX_NUM_CHANNEL; i++) |
| prtd->channel_map[i] = |
| (char)(ucontrol->value.integer.value[i]); |
| } |
| return 0; |
| } |
| |
| static int msm_pcm_chmap_ctl_get(struct snd_kcontrol *kcontrol, |
| struct snd_ctl_elem_value *ucontrol) |
| { |
| int i; |
| struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol); |
| unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); |
| struct snd_pcm_substream *substream; |
| struct msm_audio *prtd; |
| |
| pr_debug("%s", __func__); |
| substream = snd_pcm_chmap_substream(info, idx); |
| if (!substream) |
| return -ENODEV; |
| memset(ucontrol->value.integer.value, 0, |
| sizeof(ucontrol->value.integer.value)); |
| if (!substream->runtime) |
| return 0; /* no channels set */ |
| |
| prtd = substream->runtime->private_data; |
| |
| if (prtd && prtd->set_channel_map == true) { |
| for (i = 0; i < PCM_FORMAT_MAX_NUM_CHANNEL; i++) |
| ucontrol->value.integer.value[i] = |
| (int)prtd->channel_map[i]; |
| } else { |
| for (i = 0; i < PCM_FORMAT_MAX_NUM_CHANNEL; i++) |
| ucontrol->value.integer.value[i] = 0; |
| } |
| |
| return 0; |
| } |
| |
| static int msm_asoc_pcm_new(struct snd_soc_pcm_runtime *rtd) |
| { |
| struct snd_card *card = rtd->card->snd_card; |
| struct snd_pcm *pcm = rtd->pcm; |
| struct snd_pcm_chmap *chmap_info; |
| struct snd_kcontrol *kctl; |
| char device_num[12]; |
| int i, ret = 0; |
| |
| if (!card->dev->coherent_dma_mask) |
| card->dev->coherent_dma_mask = DMA_BIT_MASK(32); |
| |
| pr_debug("%s, Channel map cntrl add\n", __func__); |
| ret = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK, |
| snd_pcm_std_chmaps, |
| PCM_FORMAT_MAX_NUM_CHANNEL, 0, |
| &chmap_info); |
| if (ret < 0) |
| return ret; |
| kctl = chmap_info->kctl; |
| for (i = 0; i < kctl->count; i++) |
| kctl->vd[i].access |= SNDRV_CTL_ELEM_ACCESS_WRITE; |
| snprintf(device_num, sizeof(device_num), "%d", pcm->device); |
| strlcat(kctl->id.name, device_num, sizeof(kctl->id.name)); |
| pr_debug("%s, Overwriting channel map control name to: %s", |
| __func__, kctl->id.name); |
| kctl->put = msm_pcm_chmap_ctl_put; |
| kctl->get = msm_pcm_chmap_ctl_get; |
| return ret; |
| } |
| |
| static struct snd_soc_platform_driver msm_soc_platform = { |
| .ops = &msm_pcm_ops, |
| .pcm_new = msm_asoc_pcm_new, |
| }; |
| |
| static __devinit int msm_pcm_probe(struct platform_device *pdev) |
| { |
| int rc; |
| int id; |
| struct msm_plat_data *pdata; |
| const char *latency_level; |
| |
| rc = of_property_read_u32(pdev->dev.of_node, |
| "qti,msm-pcm-dsp-id", &id); |
| if (rc) { |
| dev_err(&pdev->dev, "%s: qti,msm-pcm-dsp-id missing in DT node\n", |
| __func__); |
| return rc; |
| } |
| |
| pdata = kzalloc(sizeof(struct msm_plat_data), GFP_KERNEL); |
| if (!pdata) { |
| dev_err(&pdev->dev, "Failed to allocate memory for platform data\n"); |
| return -ENOMEM; |
| } |
| |
| if (of_property_read_bool(pdev->dev.of_node, |
| "qti,msm-pcm-low-latency")) { |
| |
| pdata->perf_mode = LOW_LATENCY_PCM_MODE; |
| rc = of_property_read_string(pdev->dev.of_node, |
| "qti,latency-level", &latency_level); |
| if (!rc) { |
| if (!strcmp(latency_level, "ultra")) |
| pdata->perf_mode = ULTRA_LOW_LATENCY_PCM_MODE; |
| } |
| } else |
| pdata->perf_mode = LEGACY_PCM_MODE; |
| |
| dev_set_drvdata(&pdev->dev, pdata); |
| |
| dev_set_name(&pdev->dev, "%s.%d", "msm-pcm-dsp", id); |
| |
| dev_dbg(&pdev->dev, "%s: dev name %s\n", |
| __func__, dev_name(&pdev->dev)); |
| return snd_soc_register_platform(&pdev->dev, |
| &msm_soc_platform); |
| } |
| |
| static int msm_pcm_remove(struct platform_device *pdev) |
| { |
| struct msm_plat_data *pdata; |
| |
| pdata = dev_get_drvdata(&pdev->dev); |
| kfree(pdata); |
| snd_soc_unregister_platform(&pdev->dev); |
| return 0; |
| } |
| static const struct of_device_id msm_pcm_dt_match[] = { |
| {.compatible = "qti,msm-pcm-dsp"}, |
| {} |
| }; |
| MODULE_DEVICE_TABLE(of, msm_pcm_dt_match); |
| |
| static struct platform_driver msm_pcm_driver = { |
| .driver = { |
| .name = "msm-pcm-dsp", |
| .owner = THIS_MODULE, |
| .of_match_table = msm_pcm_dt_match, |
| }, |
| .probe = msm_pcm_probe, |
| .remove = __devexit_p(msm_pcm_remove), |
| }; |
| |
| static int __init msm_soc_platform_init(void) |
| { |
| init_waitqueue_head(&the_locks.enable_wait); |
| init_waitqueue_head(&the_locks.eos_wait); |
| init_waitqueue_head(&the_locks.write_wait); |
| init_waitqueue_head(&the_locks.read_wait); |
| |
| return platform_driver_register(&msm_pcm_driver); |
| } |
| module_init(msm_soc_platform_init); |
| |
| static void __exit msm_soc_platform_exit(void) |
| { |
| platform_driver_unregister(&msm_pcm_driver); |
| } |
| module_exit(msm_soc_platform_exit); |
| |
| MODULE_DESCRIPTION("PCM module platform driver"); |
| MODULE_LICENSE("GPL v2"); |