| /************************************************************************************* |
| * Copyright (C) 2007-2011 |
| * Copyright ? 2007 Marvell International Ltd. |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version 2 |
| * of the License, or (at your option) any later version. |
| * |
| * 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. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| * |
| ***************************************************************************************/ |
| #include <linux/module.h> |
| #include <linux/atomic.h> |
| #include <linux/version.h> |
| #include <linux/init.h> |
| #include <linux/jiffies.h> |
| #include <linux/slab.h> |
| #include <linux/time.h> |
| #include <linux/wait.h> |
| #include <linux/socket.h> |
| #include <linux/spinlock.h> |
| #include <linux/file.h> |
| #include <linux/completion.h> |
| #include <asm/cacheflush.h> |
| #include <linux/dma-mapping.h> |
| |
| #include <sound/core.h> |
| #include <sound/control.h> |
| #include <sound/hwdep.h> |
| #include <sound/info.h> |
| #include <sound/initval.h> |
| #include <sound/pcm.h> |
| #include <sound/pcm_params.h> |
| #include <sound/pcm-indirect.h> |
| #include <sound/rawmidi.h> |
| |
| #include "berlin_memmap.h" |
| #include "api_avio_dhub.h" |
| #include "api_dhub.h" |
| #include "api_aio.h" |
| #include "api_spdif.h" |
| #include "spdif_enc.h" |
| #include "api_avpll.h" |
| #include "api_playback.h" |
| #include "pcm.h" |
| |
| enum { |
| SND_BERLIN_OUTPUT_ANALOG = 0x200, |
| SND_BERLIN_OUTPUT_SPDIF, |
| }; |
| |
| #define MIN_PERIOD_SIZE (1 * 1024) |
| #define MAX_PERIOD_SIZE (2 * 1024) |
| #define MAX_BUFFER_SIZE (32 * 1024) |
| |
| struct snd_berlin_card_pcm { |
| /* |
| * Driver-specific debug proc entry |
| */ |
| struct snd_info_entry *entry; |
| |
| /* |
| * Tracks the base address of the last submitted DMA block. |
| * Moved to next period in ISR. |
| * Read in snd_berlin_playback_pointer. |
| * Offset is given in the format received from userspace ("virtual |
| * bytes"). |
| * Access under lock. |
| */ |
| unsigned int current_virt_dma_offset; |
| |
| /* |
| * Is there a submitted DMA request? |
| * Set when a DMA request is submitted to DHUB. |
| * Cleared on 'stop' or ISR. |
| * Access under lock. |
| */ |
| bool dma_pending; |
| /* |
| * unmute audio when first DMA is back |
| */ |
| bool need_unmute_audio; |
| /* |
| * Indicates if page memory is allocated |
| */ |
| bool pages_allocated; |
| |
| /* |
| * Instance lock between ISR and higher contexts. |
| */ |
| spinlock_t lock; |
| |
| /* spdif DMA buffer */ |
| unsigned char *spdif_dma_area; /* dma buffer for spdif output */ |
| dma_addr_t spdif_dma_addr; /* physical address of spdif buffer */ |
| unsigned int spdif_dma_bytes; /* size of spdif dma area */ |
| |
| /* PCM DMA buffer */ |
| unsigned char *pcm_dma_area; |
| dma_addr_t pcm_dma_addr; |
| /* Total size of ALSA buffer in the format that would be DMAed */ |
| unsigned int pcm_dma_bytes; |
| /* Total size of ALSA buffer in the format received from userspace. |
| * Note that 16 bit input is padded out to 32. */ |
| unsigned int pcm_virt_bytes; |
| /* Size of data sent in one DMA transfer, in the format received from |
| * userspace. |
| */ |
| unsigned int pcm_virt_period_bytes; |
| |
| |
| /* hw parameter */ |
| unsigned int sample_rate; |
| unsigned int sample_format; |
| unsigned int channel_num; |
| unsigned int pcm_ratio; |
| unsigned int spdif_ratio; |
| |
| /* for spdif encoding */ |
| unsigned int spdif_frames; |
| unsigned char channel_status[24]; |
| |
| /* playback status */ |
| bool playing; |
| unsigned int output_mode; |
| |
| struct snd_pcm_substream *substream; |
| struct snd_pcm_indirect pcm_indirect; |
| }; |
| |
| atomic_t g_output_mode = ATOMIC_INIT(SND_BERLIN_OUTPUT_ANALOG); |
| |
| static unsigned int berlin_playback_rates[] = { |
| 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, |
| 64000, 88200, 96000 |
| }; |
| |
| static struct snd_pcm_hw_constraint_list berlin_constraints_rates = { |
| .count = ARRAY_SIZE(berlin_playback_rates), |
| .list = berlin_playback_rates, |
| .mask = 0, |
| }; |
| |
| /* |
| * Applies output configuration of |berlin_pcm| to i2s. |
| * Must be called with instance spinlock held. |
| */ |
| static void berlin_set_aio(const struct snd_berlin_card_pcm *berlin_pcm) |
| { |
| unsigned int analog_div, spdif_div; |
| |
| assert_spin_locked(&berlin_pcm->lock); |
| |
| AIO_SetAudChMute(AIO_SEC, AIO_TSD0, AUDCH_CTRL_MUTE_MUTE_ON); |
| AIO_SetAudChEn(AIO_SEC, AIO_TSD0, AUDCH_CTRL_ENABLE_DISABLE); |
| |
| // update berlin_playback_rates if any rates are added or removed. |
| switch (berlin_pcm->sample_rate) { |
| case 8000 : |
| case 11025 : |
| case 12000 : |
| analog_div = AIO_DIV32; |
| spdif_div = AIO_DIV16; |
| break; |
| case 16000 : |
| case 22050 : |
| case 24000 : |
| analog_div = AIO_DIV16; |
| spdif_div = AIO_DIV8; |
| break; |
| case 32000 : |
| case 44100 : |
| case 48000 : |
| analog_div = AIO_DIV8; |
| spdif_div = AIO_DIV4; |
| break; |
| case 64000 : |
| case 88200 : |
| case 96000 : |
| analog_div = AIO_DIV4; |
| spdif_div = AIO_DIV2; |
| break; |
| default: |
| break; |
| } |
| |
| if (berlin_pcm->output_mode == SND_BERLIN_OUTPUT_ANALOG) { |
| AIO_SetClkDiv(AIO_SEC, analog_div); |
| AIO_SetCtl(AIO_SEC, AIO_I2S_MODE, AIO_32CFM, AIO_24DFM); |
| } else if (berlin_pcm->output_mode == SND_BERLIN_OUTPUT_SPDIF) { |
| AIO_SetClkDiv(AIO_SEC, spdif_div); |
| AIO_SetCtl(AIO_SEC, AIO_I2S_MODE, AIO_32CFM, AIO_32DFM); |
| } |
| |
| AIO_SetAudChEn(AIO_SEC, AIO_TSD0, AUDCH_CTRL_ENABLE_ENABLE); |
| |
| // Only unmute if we were playing. |
| if (berlin_pcm->playing) |
| AIO_SetAudChMute(AIO_SEC, AIO_TSD0, AUDCH_CTRL_MUTE_MUTE_OFF); |
| } |
| |
| static void berlin_set_pll(unsigned int sample_rate) |
| { |
| int apll; |
| |
| switch (sample_rate) { |
| case 11025 : |
| case 22050 : |
| case 44100 : |
| case 88200 : |
| apll = 22579200; |
| break; |
| case 8000 : |
| case 16000 : |
| case 32000 : |
| case 64000 : |
| apll = 16384000; |
| break; |
| case 12000 : |
| case 24000 : |
| case 48000 : |
| case 96000 : |
| apll = 24576000; |
| break; |
| default : |
| apll = 24576000; |
| break; |
| } |
| // WARNING: AVPLL channel 4 is reserved for PDM capture. DO NOT |
| // set parameters for it here |
| AVPLL_Set(0, 3, apll); |
| } |
| |
| /* |
| * Kicks off a DMA transfer to audio IO interface for the |berlin_pcm|. |
| * Must be called with instance spinlock held. |
| * Must be called only when instance is in playing state. |
| */ |
| static void start_dma_if_needed(struct snd_berlin_card_pcm *berlin_pcm) |
| { |
| const unsigned int chanId = avioDhubChMap_ag_SA0_R_A0; |
| unsigned int mode; |
| dma_addr_t dma_source_address; |
| int dma_size; |
| |
| assert_spin_locked(&berlin_pcm->lock); |
| |
| if (!berlin_pcm->playing) { |
| snd_printd("%s: playing: %u\n", __func__, berlin_pcm->playing); |
| return; |
| } |
| |
| if (berlin_pcm->pcm_indirect.hw_ready < berlin_pcm->pcm_virt_period_bytes) { |
| berlin_report_xrun(PCM_UNDERRUN); |
| snd_printk("%s: underrun! hw_ready: %d\n", __func__, |
| berlin_pcm->pcm_indirect.hw_ready); |
| return; |
| } |
| |
| if (berlin_pcm->dma_pending) |
| return; |
| |
| mode = atomic_read(&g_output_mode); |
| if (berlin_pcm->output_mode != mode) { |
| berlin_pcm->output_mode = mode; |
| berlin_set_aio(berlin_pcm); |
| } |
| |
| if (mode == SND_BERLIN_OUTPUT_ANALOG) { |
| dma_source_address = berlin_pcm->pcm_dma_addr + |
| berlin_pcm->current_virt_dma_offset * berlin_pcm->pcm_ratio; |
| dma_size = berlin_pcm->pcm_virt_period_bytes * berlin_pcm->pcm_ratio; |
| } else { |
| dma_source_address = berlin_pcm->spdif_dma_addr + |
| berlin_pcm->current_virt_dma_offset * berlin_pcm->spdif_ratio; |
| dma_size = berlin_pcm->pcm_virt_period_bytes * berlin_pcm->spdif_ratio; |
| } |
| |
| berlin_pcm->dma_pending = true; |
| |
| dhub_channel_write_cmd(&AG_dhubHandle.dhub, chanId, |
| dma_source_address, dma_size, 0, 0, 0, 1, 0, 0); |
| } |
| |
| static void snd_berlin_playback_trigger_start(struct snd_pcm_substream *substream) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct snd_berlin_card_pcm *berlin_pcm = runtime->private_data; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&berlin_pcm->lock, flags); |
| if (berlin_pcm->playing) { |
| spin_unlock_irqrestore(&berlin_pcm->lock, flags); |
| return; |
| } |
| |
| berlin_pcm->playing = true; |
| AIO_SetAudChFlush(AIO_SEC, AIO_TSD0, AUDCH_CTRL_FLUSH_ON); |
| AIO_SetAudChFlush(AIO_SEC, AIO_TSD0, AUDCH_CTRL_FLUSH_OFF); |
| //AIO_SetAudChMute(AIO_SEC, AIO_TSD0, AUDCH_CTRL_MUTE_MUTE_OFF); |
| berlin_pcm->need_unmute_audio = true; |
| start_dma_if_needed(berlin_pcm); |
| spin_unlock_irqrestore(&berlin_pcm->lock, flags); |
| snd_printd("%s: finished.\n", __func__); |
| } |
| |
| static void snd_berlin_playback_trigger_stop(struct snd_pcm_substream *substream) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct snd_berlin_card_pcm *berlin_pcm = runtime->private_data; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&berlin_pcm->lock, flags); |
| AIO_SetAudChMute(AIO_SEC, AIO_TSD0, AUDCH_CTRL_MUTE_MUTE_ON); |
| berlin_pcm->playing = false; |
| berlin_pcm->dma_pending = false; |
| spin_unlock_irqrestore(&berlin_pcm->lock, flags); |
| snd_printd("%s: finished.\n", __func__); |
| } |
| |
| static const struct snd_pcm_hardware snd_berlin_playback_hw = { |
| .info = (SNDRV_PCM_INFO_MMAP |
| | SNDRV_PCM_INFO_INTERLEAVED |
| | SNDRV_PCM_INFO_MMAP_VALID |
| | SNDRV_PCM_INFO_PAUSE |
| | SNDRV_PCM_INFO_RESUME), |
| .formats = (SNDRV_PCM_FMTBIT_S32_LE |
| | SNDRV_PCM_FMTBIT_S16_LE), |
| .rates = (SNDRV_PCM_RATE_8000_96000 |
| | SNDRV_PCM_RATE_KNOT), |
| .rate_min = 8000, |
| .rate_max = 96000, |
| .channels_min = 1, |
| .channels_max = 2, |
| .buffer_bytes_max = MAX_BUFFER_SIZE, |
| .period_bytes_min = MIN_PERIOD_SIZE, |
| .period_bytes_max = MAX_PERIOD_SIZE, |
| .periods_min = 2, |
| .periods_max = MAX_BUFFER_SIZE / MIN_PERIOD_SIZE, |
| .fifo_size = 0 |
| }; |
| |
| static void snd_berlin_runtime_free(struct snd_pcm_runtime *runtime) |
| { |
| struct snd_berlin_card_pcm *berlin_pcm = runtime->private_data; |
| if (berlin_pcm) { |
| if (berlin_pcm->spdif_dma_area) { |
| dma_free_coherent(NULL, berlin_pcm->spdif_dma_bytes, |
| berlin_pcm->spdif_dma_area, |
| berlin_pcm->spdif_dma_addr); |
| berlin_pcm->spdif_dma_area = NULL; |
| berlin_pcm->spdif_dma_addr = 0; |
| } |
| |
| if (berlin_pcm->pcm_dma_area) { |
| dma_free_coherent(NULL, berlin_pcm->pcm_dma_bytes, |
| berlin_pcm->pcm_dma_area, |
| berlin_pcm->pcm_dma_addr); |
| berlin_pcm->pcm_dma_area = NULL; |
| berlin_pcm->pcm_dma_addr = 0; |
| } |
| |
| if (berlin_pcm->entry) |
| snd_info_free_entry(berlin_pcm->entry); |
| |
| kfree(berlin_pcm); |
| } |
| } |
| |
| static void debug_entry(struct snd_info_entry *entry, |
| struct snd_info_buffer *buffer) |
| { |
| struct snd_berlin_card_pcm *berlin_pcm = |
| (struct snd_berlin_card_pcm *)entry->private_data; |
| unsigned long flags; |
| spin_lock_irqsave(&berlin_pcm->lock, flags); |
| snd_iprintf(buffer, "playing:\t\t%d\n", berlin_pcm->playing); |
| snd_iprintf(buffer, "dma_pending:\t\t%d\n", berlin_pcm->dma_pending); |
| snd_iprintf(buffer, "output_mode:\t\t%d\n", berlin_pcm->output_mode); |
| snd_iprintf(buffer, "current_virt_dma_offset:\t%u\n", |
| berlin_pcm->current_virt_dma_offset); |
| snd_iprintf(buffer, "\n"); |
| snd_iprintf(buffer, "indirect.hw_data:\t%u\n", |
| berlin_pcm->pcm_indirect.hw_data); |
| snd_iprintf(buffer, "indirect.hw_io:\t\t%u\n", |
| berlin_pcm->pcm_indirect.hw_io); |
| snd_iprintf(buffer, "indirect.hw_ready:\t%d\n", |
| berlin_pcm->pcm_indirect.hw_ready); |
| snd_iprintf(buffer, "indirect.sw_data:\t%u\n", |
| berlin_pcm->pcm_indirect.hw_data); |
| snd_iprintf(buffer, "indirect.sw_io:\t\t%u\n", |
| berlin_pcm->pcm_indirect.hw_io); |
| snd_iprintf(buffer, "indirect.sw_ready:\t%d\n", |
| berlin_pcm->pcm_indirect.sw_ready); |
| snd_iprintf(buffer, "indirect.appl_ptr:\t%lu\n", |
| berlin_pcm->pcm_indirect.appl_ptr); |
| snd_iprintf(buffer, "\n"); |
| snd_iprintf(buffer, "substream->runtime->control->appl_ptr:\t%lu\n", |
| berlin_pcm->substream->runtime->control->appl_ptr); |
| snd_iprintf(buffer, "substream->runtime->status->hw_ptr:\t%lu\n", |
| berlin_pcm->substream->runtime->status->hw_ptr); |
| spin_unlock_irqrestore(&berlin_pcm->lock, flags); |
| } |
| |
| int snd_berlin_playback_open(struct snd_pcm_substream *substream) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct snd_berlin_card_pcm *berlin_pcm; |
| |
| int err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, |
| &berlin_constraints_rates); |
| if (err < 0) { |
| snd_printk("%s: Invalid sample rate.\n", __func__); |
| return err; |
| } |
| |
| err = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, |
| MIN_PERIOD_SIZE); |
| if (err < 0) { |
| snd_printk("%s: Invalid period size.\n", __func__); |
| return err; |
| } |
| |
| berlin_pcm = kzalloc(sizeof(*berlin_pcm), GFP_KERNEL); |
| if (berlin_pcm == NULL) |
| return -ENOMEM; |
| |
| berlin_pcm->entry = snd_info_create_card_entry(substream->pcm->card, |
| "debug", substream->proc_root); |
| if (!berlin_pcm->entry) { |
| snd_printk("%s: couldn't create debug entry\n", __func__); |
| } else { |
| snd_info_set_text_ops(berlin_pcm->entry, berlin_pcm, debug_entry); |
| snd_info_register(berlin_pcm->entry); |
| } |
| |
| berlin_pcm->dma_pending = false; |
| berlin_pcm->playing = false; |
| berlin_pcm->pages_allocated = false; |
| berlin_pcm->output_mode = atomic_read(&g_output_mode); |
| berlin_pcm->substream = substream; |
| spin_lock_init(&berlin_pcm->lock); |
| |
| runtime->private_data = berlin_pcm; |
| runtime->private_free = snd_berlin_runtime_free; |
| runtime->hw = snd_berlin_playback_hw; |
| |
| /* enable audio interrupt */ |
| DhubEnableIntr(0, &AG_dhubHandle, avioDhubChMap_ag_SA0_R_A0, 1); |
| |
| // Enable i2s channel without corresponding disable in close. |
| // This is intentional: Avoid SPDIF sink 'activation delay' problems. |
| AIO_SetAudChEn(AIO_SEC, AIO_TSD0, AUDCH_CTRL_ENABLE_ENABLE); |
| AIO_SetAudChMute(AIO_SEC, AIO_TSD0, AUDCH_CTRL_MUTE_MUTE_ON); |
| |
| snd_printd("%s: finished.\n", __func__); |
| return 0; |
| } |
| |
| int snd_berlin_playback_close(struct snd_pcm_substream *substream) |
| { |
| DhubEnableIntr(0, &AG_dhubHandle, avioDhubChMap_ag_SA0_R_A0, 0); |
| snd_printd("%s: finished.\n", __func__); |
| return 0; |
| } |
| |
| int snd_berlin_playback_hw_free(struct snd_pcm_substream *substream) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct snd_berlin_card_pcm *berlin_pcm = runtime->private_data; |
| |
| if (berlin_pcm->spdif_dma_area) { |
| dma_free_coherent(NULL, berlin_pcm->spdif_dma_bytes, |
| berlin_pcm->spdif_dma_area, |
| berlin_pcm->spdif_dma_addr); |
| berlin_pcm->spdif_dma_area = NULL; |
| berlin_pcm->spdif_dma_addr = 0; |
| } |
| |
| if (berlin_pcm->pcm_dma_area) { |
| dma_free_coherent(NULL, berlin_pcm->pcm_dma_bytes, |
| berlin_pcm->pcm_dma_area, |
| berlin_pcm->pcm_dma_addr); |
| berlin_pcm->pcm_dma_area = NULL; |
| berlin_pcm->pcm_dma_addr = 0; |
| } |
| |
| if (berlin_pcm->pages_allocated == true) { |
| snd_pcm_lib_free_pages(substream); |
| berlin_pcm->pages_allocated = false; |
| } |
| |
| return 0; |
| } |
| |
| int snd_berlin_playback_hw_params(struct snd_pcm_substream *substream, |
| struct snd_pcm_hw_params *params) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct snd_berlin_card_pcm *berlin_pcm = runtime->private_data; |
| struct spdif_channel_status *chnsts; |
| int err; |
| unsigned long flags; |
| const size_t buffer_size_bytes = params_buffer_bytes(params); |
| const size_t period_size_bytes = buffer_size_bytes / params_periods(params); |
| |
| snd_berlin_playback_hw_free(substream); |
| |
| err = snd_pcm_lib_malloc_pages(substream, buffer_size_bytes); |
| if (err < 0) { |
| snd_printk("pcm_lib_malloc failed to allocated pages for buffers\n"); |
| return err; |
| } |
| berlin_pcm->pages_allocated = true; |
| |
| snd_printk("%s: sample_rate:%d channels:%d format:%s\n", __func__, |
| params_rate(params), params_channels(params), |
| snd_pcm_format_name(params_format(params))); |
| |
| berlin_pcm->sample_rate = params_rate(params); |
| berlin_pcm->sample_format = params_format(params); |
| berlin_pcm->channel_num = params_channels(params); |
| berlin_pcm->pcm_ratio = 1; |
| |
| if (berlin_pcm->sample_format == SNDRV_PCM_FORMAT_S16_LE) |
| berlin_pcm->pcm_ratio *= 2; |
| if (berlin_pcm->channel_num == 1) |
| berlin_pcm->pcm_ratio *= 2; |
| |
| berlin_pcm->spdif_ratio = berlin_pcm->pcm_ratio * 2; |
| |
| berlin_pcm->pcm_virt_period_bytes = period_size_bytes; |
| berlin_pcm->pcm_virt_bytes = buffer_size_bytes; |
| berlin_pcm->pcm_dma_bytes = berlin_pcm->pcm_virt_bytes * |
| berlin_pcm->pcm_ratio; |
| berlin_pcm->pcm_dma_area = dma_zalloc_coherent( |
| NULL, berlin_pcm->pcm_dma_bytes, |
| &berlin_pcm->pcm_dma_addr, GFP_KERNEL); |
| if (!berlin_pcm->pcm_dma_area) { |
| snd_printk("%s: failed to allocate PCM DMA area\n", __func__); |
| goto err_pcm_dma; |
| } |
| |
| berlin_pcm->spdif_dma_bytes = berlin_pcm->pcm_virt_bytes * |
| berlin_pcm->spdif_ratio; |
| berlin_pcm->spdif_dma_area = dma_zalloc_coherent( |
| NULL, berlin_pcm->spdif_dma_bytes, |
| &berlin_pcm->spdif_dma_addr, GFP_KERNEL); |
| if (!berlin_pcm->spdif_dma_area) { |
| snd_printk("%s: failed to allocate SPDIF DMA area\n", __func__); |
| goto err_spdif_dma; |
| } |
| |
| /* initialize spdif channel status */ |
| chnsts = (struct spdif_channel_status *)&(berlin_pcm->channel_status[0]); |
| spdif_init_channel_status(chnsts, berlin_pcm->sample_rate); |
| |
| /* AVPLL configuration */ |
| berlin_set_pll(berlin_pcm->sample_rate); |
| |
| spin_lock_irqsave(&berlin_pcm->lock, flags); |
| /* AIO configuration */ |
| berlin_set_aio(berlin_pcm); |
| spin_unlock_irqrestore(&berlin_pcm->lock, flags); |
| |
| return 0; |
| |
| err_spdif_dma: |
| if (berlin_pcm->pcm_dma_area) |
| dma_free_coherent(NULL, berlin_pcm->pcm_dma_bytes, |
| berlin_pcm->pcm_dma_area, berlin_pcm->pcm_dma_addr); |
| berlin_pcm->pcm_dma_area = NULL; |
| berlin_pcm->pcm_dma_addr = 0; |
| err_pcm_dma: |
| snd_pcm_lib_free_pages(substream); |
| return -ENOMEM; |
| } |
| |
| int snd_berlin_playback_prepare(struct snd_pcm_substream *substream) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct snd_berlin_card_pcm *berlin_pcm = runtime->private_data; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&berlin_pcm->lock, flags); |
| berlin_pcm->current_virt_dma_offset = 0; |
| memset(&berlin_pcm->pcm_indirect, 0, sizeof(berlin_pcm->pcm_indirect)); |
| /* Typically pcm_indirect is used to fake period/buffer size flexibility |
| * for hardware with a fixed period/buffer size configuration. |
| * In this case it is only used as an intermediate buffer for MMAP |
| * support. Note that pcm_indirect is not strictly necessary for an |
| * intermediate buffer (we could use the existing allocated DMA areas), |
| * but because we convert to SPDIF, expand mono output and expand 16 bit |
| * samples to 32 by bitbanging, we cannot write directly into those |
| * buffers. |
| */ |
| berlin_pcm->pcm_indirect.hw_buffer_size = snd_pcm_lib_buffer_bytes(substream); |
| berlin_pcm->pcm_indirect.sw_buffer_size = snd_pcm_lib_buffer_bytes(substream); |
| spin_unlock_irqrestore(&berlin_pcm->lock, flags); |
| |
| snd_printd("%s finished. buffer_bytes: %d period_bytes: %d\n", __func__, |
| snd_pcm_lib_buffer_bytes(substream), |
| snd_pcm_lib_period_bytes(substream)); |
| return 0; |
| } |
| |
| int snd_berlin_playback_trigger(struct snd_pcm_substream *substream, int cmd) |
| { |
| int ret = 0; |
| |
| switch (cmd) { |
| case SNDRV_PCM_TRIGGER_START: |
| case SNDRV_PCM_TRIGGER_RESUME: |
| case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: |
| snd_berlin_playback_trigger_start(substream); |
| break; |
| case SNDRV_PCM_TRIGGER_STOP: |
| case SNDRV_PCM_TRIGGER_SUSPEND: |
| case SNDRV_PCM_TRIGGER_PAUSE_PUSH: |
| snd_berlin_playback_trigger_stop(substream); |
| break; |
| default: |
| ret = -EINVAL; |
| } |
| |
| return ret; |
| } |
| |
| snd_pcm_uframes_t |
| snd_berlin_playback_pointer(struct snd_pcm_substream *substream) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct snd_berlin_card_pcm *berlin_pcm = runtime->private_data; |
| uint32_t buf_pos; |
| unsigned long flags; |
| |
| spin_lock_irqsave(&berlin_pcm->lock, flags); |
| buf_pos = berlin_pcm->current_virt_dma_offset; |
| spin_unlock_irqrestore(&berlin_pcm->lock, flags); |
| |
| return snd_pcm_indirect_playback_pointer(substream, &berlin_pcm->pcm_indirect, |
| buf_pos); |
| } |
| |
| // Encodes |frames| number of stereo S32LE frames from |pcm_in| |
| // to |spdif_out| SPDIF frames (64-bits per frame) |
| static void spdif_encode(struct snd_berlin_card_pcm *berlin_pcm, |
| const int32_t *pcm_in, int32_t *spdif_out, int frames) |
| { |
| int i; |
| for (i = 0; i < frames; ++i) { |
| unsigned char channel_status = |
| spdif_get_channel_status(berlin_pcm->channel_status, |
| berlin_pcm->spdif_frames); |
| unsigned int sync_word = |
| berlin_pcm->spdif_frames ? TYPE_M : TYPE_B; |
| spdif_enc_subframe(&spdif_out[i * 4], |
| pcm_in[i * 2], sync_word, 0, 0, channel_status); |
| |
| sync_word = TYPE_W; |
| spdif_enc_subframe(&spdif_out[(i * 4) + 2], |
| pcm_in[(i * 2) + 1], sync_word, 0, 0, channel_status); |
| |
| ++berlin_pcm->spdif_frames; |
| berlin_pcm->spdif_frames %= SPDIF_BLOCK_SIZE; |
| } |
| } |
| |
| /* Copies (and converts as necessary) data from the pcm_indirect buffer into |
| * the PCM and SPDIF DMA buffers. |
| */ |
| static int snd_berlin_playback_copy(struct snd_pcm_substream *substream, |
| int channel, snd_pcm_uframes_t pos, |
| void *buf, size_t bytes) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct snd_berlin_card_pcm *berlin_pcm = runtime->private_data; |
| int32_t *pcm_buf = (int32_t *)(berlin_pcm->pcm_dma_area + |
| pos * berlin_pcm->pcm_ratio); |
| int32_t *spdif_buf = (int32_t *)(berlin_pcm->spdif_dma_area + |
| pos * berlin_pcm->spdif_ratio); |
| const int frames = bytes / |
| (berlin_pcm->channel_num * |
| snd_pcm_format_width(berlin_pcm->sample_format) / 8); |
| int i; |
| |
| if (pos >= berlin_pcm->pcm_virt_bytes) |
| return -EINVAL; |
| |
| if (berlin_pcm->pcm_indirect.hw_ready >= berlin_pcm->pcm_virt_period_bytes) { |
| unsigned long flags; |
| unsigned long dma_begin, dma_end, write_begin, write_end; |
| |
| spin_lock_irqsave(&berlin_pcm->lock, flags); |
| dma_begin = berlin_pcm->current_virt_dma_offset; |
| spin_unlock_irqrestore(&berlin_pcm->lock, flags); |
| dma_end = dma_begin + berlin_pcm->pcm_virt_period_bytes - 1; |
| write_begin = pos; |
| write_end = write_begin + bytes - 1; |
| |
| // Write begin position shouldn't be in DMA area. |
| if ((dma_begin <= write_begin) && (write_begin <= dma_end)) { |
| snd_printk("%s: dma_begin:%lu <= write_begin:%lu " |
| "<= dma_end:%lu\n", |
| __func__, dma_begin, write_begin, dma_end); |
| } |
| |
| // Write end position shouldn't be in DMA area. |
| if ((dma_begin <= write_end) && (write_end <= dma_end)) { |
| snd_printk("%s: dma_begin:%lu <= write_end:%lu <= " |
| "dma_end:%lu\n", |
| __func__, dma_begin, write_end, dma_end); |
| } |
| |
| // Write shouldn't overlap DMA area. |
| if ((write_begin <= dma_begin) && (write_end >= dma_end)) { |
| snd_printk("%s: write_begin:%lu <= dma_begin:%lu && " |
| "write_end:%lu >= dma_end:%lu\n", |
| __func__, write_begin, dma_begin, |
| write_end, dma_end); |
| } |
| } |
| |
| if (berlin_pcm->sample_format == SNDRV_PCM_FORMAT_S16_LE) { |
| const int16_t *s16_pcm_source = (int16_t *)buf; |
| |
| if (berlin_pcm->channel_num == 1) { |
| // Shift sample to 32-bits, and upmix to stereo. |
| for (i = 0; i < frames; ++i) { |
| const int32_t s32_sample = s16_pcm_source[i] << 16; |
| pcm_buf[i * 2] = s32_sample; |
| pcm_buf[(i * 2) + 1] = s32_sample; |
| } |
| } else { |
| // Copy left and right samples while shifting to 32-bits. |
| for (i = 0; i < frames; ++i) { |
| pcm_buf[i * 2] = |
| s16_pcm_source[i * 2] << 16; |
| pcm_buf[(i * 2) + 1] = |
| s16_pcm_source[(i * 2) + 1] << 16; |
| } |
| } |
| } else if (berlin_pcm->sample_format == SNDRV_PCM_FORMAT_S32_LE) { |
| const int32_t *s32_pcm_source = (int32_t *)buf; |
| |
| if (berlin_pcm->channel_num == 1) { |
| // Upmix each sample to stereo. |
| for (i = 0; i < frames; ++i) { |
| pcm_buf[i * 2] = s32_pcm_source[i]; |
| pcm_buf[(i * 2) + 1] = s32_pcm_source[i]; |
| } |
| } else { |
| // Copy the left and right samples straight over. |
| for (i = 0; i < frames; ++i) { |
| pcm_buf[i * 2] = s32_pcm_source[i * 2]; |
| pcm_buf[(i * 2) + 1] = s32_pcm_source[(i * 2) + 1]; |
| } |
| } |
| } else { |
| return -EINVAL; |
| } |
| |
| spdif_encode(berlin_pcm, pcm_buf, spdif_buf, frames); |
| return 0; |
| } |
| |
| static void berlin_playback_transfer(struct snd_pcm_substream *substream, |
| struct snd_pcm_indirect *rec, size_t bytes) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct snd_berlin_card_pcm *berlin_pcm = runtime->private_data; |
| void *src = (void *)(runtime->dma_area + rec->sw_data); |
| if (!src) |
| return; |
| |
| snd_berlin_playback_copy(substream, berlin_pcm->channel_num, |
| rec->hw_data, src, bytes); |
| } |
| |
| int snd_berlin_playback_ack(struct snd_pcm_substream *substream) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct snd_berlin_card_pcm *berlin_pcm = runtime->private_data; |
| struct snd_pcm_indirect *pcm_indirect = &berlin_pcm->pcm_indirect; |
| unsigned long flags; |
| pcm_indirect->hw_queue_size = berlin_pcm->pcm_virt_bytes; |
| snd_pcm_indirect_playback_transfer(substream, pcm_indirect, |
| berlin_playback_transfer); |
| spin_lock_irqsave(&berlin_pcm->lock, flags); |
| start_dma_if_needed(berlin_pcm); |
| spin_unlock_irqrestore(&berlin_pcm->lock, flags); |
| return 0; |
| } |
| |
| int snd_berlin_playback_isr(struct snd_pcm_substream *substream) |
| { |
| struct snd_pcm_runtime *runtime = substream->runtime; |
| struct snd_berlin_card_pcm *berlin_pcm = runtime->private_data; |
| unsigned long flags; |
| // FIFO fullness |
| unsigned int dhub_cnt; |
| |
| if (berlin_pcm->need_unmute_audio) { |
| AIO_SetAudChMute(AIO_SEC, AIO_TSD0, AUDCH_CTRL_MUTE_MUTE_OFF); |
| berlin_pcm->need_unmute_audio = false; |
| } |
| spin_lock_irqsave(&berlin_pcm->lock, flags); |
| /* If we are not running, do not chain, and clear pending */ |
| if (!berlin_pcm->playing) { |
| berlin_pcm->dma_pending = false; |
| spin_unlock_irqrestore(&berlin_pcm->lock, flags); |
| return IRQ_HANDLED; |
| } |
| |
| /* If we were not pending, avoid pointer manipulation */ |
| if (!berlin_pcm->dma_pending) { |
| spin_unlock_irqrestore(&berlin_pcm->lock, flags); |
| return IRQ_HANDLED; |
| } |
| |
| /* Roll the DMA pointer, and chain if needed */ |
| berlin_pcm->current_virt_dma_offset += berlin_pcm->pcm_virt_period_bytes; |
| berlin_pcm->current_virt_dma_offset %= berlin_pcm->pcm_virt_bytes; |
| berlin_pcm->dma_pending = false; |
| |
| /* to query the consumer data count register to check fifo fullness */ |
| static const uintptr_t addr = AG_DHUB_BASE + RA_dHubReg_HBO + 0x80 + |
| avioDhubChMap_ag_SA0_R_A0 * 4 * 2 + 4; |
| dhub_cnt = (*((volatile unsigned int*)(addr))); |
| // According to Marvell, we only use the lower 16 bits |
| dhub_cnt &= 0xffff; |
| // The size of output FIFO is 1024 bytes |
| // dhub count is in units of 64 bit frames (2 channel, 4 byte sample). |
| // The 64 bit frames are each 8 bytes. |
| // When the size of the output FIFO is 1024 bytes, the typical dhub_cnt |
| // value is 128, which is 128*8 = 1024 bytes. |
| if (dhub_cnt <= 8) { |
| berlin_report_xrun(FIFO_UNDERRUN); |
| snd_printk("Dhub cnt: %d bytes, FIFO nearly empty\n", dhub_cnt*8); |
| } |
| |
| start_dma_if_needed(berlin_pcm); |
| spin_unlock_irqrestore(&berlin_pcm->lock, flags); |
| snd_pcm_period_elapsed(substream); |
| return 0; |
| } |
