blob: 0df685159e9c70ac004bdbfc158a68aa904132d2 [file] [log] [blame]
/*
* imx-hdmi-dma.c -- HDMI DMA driver for ALSA Soc Audio Layer
*
* Copyright (C) 2011-2014 Freescale Semiconductor, Inc.
*
* based on imx-pcm-dma-mx2.c
* Copyright 2009 Sascha Hauer <s.hauer@pengutronix.de>
*
* This code is based on code copyrighted by Freescale,
* Liam Girdwood, Javier Martin and probably others.
*
* 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.
*/
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <linux/mfd/mxc-hdmi-core.h>
#include <linux/platform_data/dma-imx.h>
#include <video/mxc_hdmi.h>
#include "imx-hdmi.h"
#define HDMI_DMA_BURST_UNSPECIFIED_LEGNTH 0
#define HDMI_DMA_BURST_INCR4 1
#define HDMI_DMA_BURST_INCR8 2
#define HDMI_DMA_BURST_INCR16 3
#define HDMI_BASE_ADDR 0x00120000
struct hdmi_sdma_script {
int control_reg_addr;
int status_reg_addr;
int dma_start_addr;
u32 buffer[20];
};
struct hdmi_dma_priv {
struct snd_pcm_substream *substream;
struct platform_device *pdev;
struct snd_dma_buffer hw_buffer;
unsigned long buffer_bytes;
unsigned long appl_bytes;
int periods;
int period_time;
int period_bytes;
int dma_period_bytes;
int buffer_ratio;
unsigned long offset;
snd_pcm_format_t format;
int sample_align;
int sample_bits;
int channels;
int rate;
int frame_idx;
bool tx_active;
spinlock_t irq_lock;
/* SDMA part */
dma_addr_t phy_hdmi_sdma_t;
struct hdmi_sdma_script *hdmi_sdma_t;
struct dma_chan *dma_channel;
struct dma_async_tx_descriptor *desc;
struct imx_hdmi_sdma_params sdma_params;
};
/* bit 0:0:0:b:p(0):c:(u)0:(v)0 */
/* max 8 channels supported; channels are interleaved */
static u8 g_packet_head_table[48 * 8];
void hdmi_dma_copy_16_neon_lut(unsigned short *src, unsigned int *dst,
int samples, unsigned char *lookup_table);
void hdmi_dma_copy_16_neon_fast(unsigned short *src, unsigned int *dst,
int samples);
void hdmi_dma_copy_24_neon_lut(unsigned int *src, unsigned int *dst,
int samples, unsigned char *lookup_table);
void hdmi_dma_copy_24_neon_fast(unsigned int *src, unsigned int *dst,
int samples);
static void hdmi_dma_irq_enable(struct hdmi_dma_priv *priv);
static void hdmi_dma_irq_disable(struct hdmi_dma_priv *priv);
union hdmi_audio_header_t iec_header;
EXPORT_SYMBOL(iec_header);
/*
* Note that the period size for DMA != period size for ALSA because the
* driver adds iec frame info to the audio samples (in hdmi_dma_copy).
*
* Each 4 byte subframe = 1 byte of iec data + 3 byte audio sample.
*
* A 16 bit audio sample becomes 32 bits including the frame info. Ratio=2
* A 24 bit audio sample becomes 32 bits including the frame info. Ratio=3:4
* If the 24 bit raw audio is in 32 bit words, the
*
* Original Packed into subframe Ratio of size Format
* sample how many size of DMA buffer
* (bits) bits to ALSA buffer
* -------- ----------- -------- -------------- ------------------------
* 16 16 32 2 SNDRV_PCM_FORMAT_S16_LE
* 24 24 32 1.33 SNDRV_PCM_FORMAT_S24_3LE*
* 24 32 32 1 SNDRV_PCM_FORMAT_S24_LE
*
* *so SNDRV_PCM_FORMAT_S24_3LE is not supported.
*/
/*
* The minimum dma period is one IEC audio frame (192 * 4 * channels).
* The maximum dma period for the HDMI DMA is 8K.
*
* channels minimum maximum
* dma period dma period
* -------- ------------------ ----------
* 2 192 * 4 * 2 = 1536 * 4 = 6144
* 4 192 * 4 * 4 = 3072 * 2 = 6144
* 6 192 * 4 * 6 = 4608 * 1 = 4608
* 8 192 * 4 * 8 = 6144 * 1 = 6144
*
* Bottom line:
* 1. Must keep the ratio of DMA buffer to ALSA buffer consistent.
* 2. frame_idx is saved in the private data, so even if a frame cannot be
* transmitted in a period, it can be continued in the next period. This
* is necessary for 6 ch.
*/
#define HDMI_DMA_PERIOD_BYTES (12288)
#define HDMI_DMA_BUF_SIZE (128 * 1024)
#define HDMI_PCM_BUF_SIZE (128 * 1024)
#define hdmi_audio_debug(dev, reg) \
dev_dbg(dev, #reg ": 0x%02x\n", hdmi_readb(reg))
#ifdef DEBUG
static void dumpregs(struct device *dev)
{
hdmi_audio_debug(dev, HDMI_AHB_DMA_CONF0);
hdmi_audio_debug(dev, HDMI_AHB_DMA_START);
hdmi_audio_debug(dev, HDMI_AHB_DMA_STOP);
hdmi_audio_debug(dev, HDMI_AHB_DMA_THRSLD);
hdmi_audio_debug(dev, HDMI_AHB_DMA_STRADDR0);
hdmi_audio_debug(dev, HDMI_AHB_DMA_STPADDR0);
hdmi_audio_debug(dev, HDMI_AHB_DMA_BSTADDR0);
hdmi_audio_debug(dev, HDMI_AHB_DMA_MBLENGTH0);
hdmi_audio_debug(dev, HDMI_AHB_DMA_MBLENGTH1);
hdmi_audio_debug(dev, HDMI_AHB_DMA_STAT);
hdmi_audio_debug(dev, HDMI_AHB_DMA_INT);
hdmi_audio_debug(dev, HDMI_AHB_DMA_MASK);
hdmi_audio_debug(dev, HDMI_AHB_DMA_POL);
hdmi_audio_debug(dev, HDMI_AHB_DMA_CONF1);
hdmi_audio_debug(dev, HDMI_AHB_DMA_BUFFSTAT);
hdmi_audio_debug(dev, HDMI_AHB_DMA_BUFFINT);
hdmi_audio_debug(dev, HDMI_AHB_DMA_BUFFMASK);
hdmi_audio_debug(dev, HDMI_AHB_DMA_BUFFPOL);
hdmi_audio_debug(dev, HDMI_IH_MUTE_AHBDMAAUD_STAT0);
hdmi_audio_debug(dev, HDMI_IH_AHBDMAAUD_STAT0);
hdmi_audio_debug(dev, HDMI_IH_MUTE);
}
static void dumppriv(struct device *dev, struct hdmi_dma_priv *priv)
{
dev_dbg(dev, "channels = %d\n", priv->channels);
dev_dbg(dev, "periods = %d\n", priv->periods);
dev_dbg(dev, "period_bytes = %d\n", priv->period_bytes);
dev_dbg(dev, "dma period_bytes = %d\n", priv->dma_period_bytes);
dev_dbg(dev, "buffer_ratio = %d\n", priv->buffer_ratio);
dev_dbg(dev, "hw dma buffer = 0x%08x\n", (int)priv->hw_buffer.addr);
dev_dbg(dev, "dma buf size = %d\n", (int)priv->buffer_bytes);
dev_dbg(dev, "sample_rate = %d\n", (int)priv->rate);
}
#else
static void dumpregs(struct device *dev) {}
static void dumppriv(struct device *dev, struct hdmi_dma_priv *priv) {}
#endif
/*
* Conditions for DMA to work:
* ((final_addr - initial_addr)>>2)+1) < 2k. So max period is 8k.
* (inital_addr & 0x3) == 0
* (final_addr & 0x3) == 0x3
*
* The DMA Period should be an integer multiple of the IEC 60958 audio
* frame size, which is 768 bytes (192 * 4).
*/
static void hdmi_dma_set_addr(int start_addr, int dma_period_bytes)
{
int final_addr = start_addr + dma_period_bytes - 1;
hdmi_write4(start_addr, HDMI_AHB_DMA_STRADDR0);
hdmi_write4(final_addr, HDMI_AHB_DMA_STPADDR0);
}
static void hdmi_dma_irq_set(bool set)
{
u8 val = hdmi_readb(HDMI_AHB_DMA_MASK);
if (set)
val |= HDMI_AHB_DMA_DONE;
else
val &= (u8)~HDMI_AHB_DMA_DONE;
hdmi_writeb(val, HDMI_AHB_DMA_MASK);
}
static void hdmi_mask(int mask)
{
u8 regval = hdmi_readb(HDMI_AHB_DMA_MASK);
if (mask)
regval |= HDMI_AHB_DMA_ERROR | HDMI_AHB_DMA_FIFO_EMPTY;
else
regval &= (u8)~(HDMI_AHB_DMA_ERROR | HDMI_AHB_DMA_FIFO_EMPTY);
hdmi_writeb(regval, HDMI_AHB_DMA_MASK);
}
int odd_ones(unsigned a)
{
a ^= a >> 8;
a ^= a >> 4;
a ^= a >> 2;
a ^= a >> 1;
return a & 1;
}
/* Add frame information for one pcm subframe */
static u32 hdmi_dma_add_frame_info(struct hdmi_dma_priv *priv,
u32 pcm_data, int subframe_idx)
{
union hdmi_audio_dma_data_t subframe;
subframe.U = 0;
iec_header.B.channel = subframe_idx;
/* fill b (start-of-block) */
subframe.B.b = (priv->frame_idx == 0) ? 1 : 0;
/* fill c (channel status) */
if (priv->frame_idx < 42)
subframe.B.c = (iec_header.U >> priv->frame_idx) & 0x1;
else
subframe.B.c = 0;
subframe.B.p = odd_ones(pcm_data);
subframe.B.p ^= subframe.B.c;
subframe.B.p ^= subframe.B.u;
subframe.B.p ^= subframe.B.v;
/* fill data */
if (priv->sample_bits == 16)
subframe.B.data = pcm_data << 8;
else
subframe.B.data = pcm_data;
return subframe.U;
}
static void init_table(int channels)
{
unsigned char *p = g_packet_head_table;
int i, ch = 0;
for (i = 0; i < 48; i++) {
int b = 0;
if (i == 0)
b = 1;
for (ch = 0; ch < channels; ch++) {
int c = 0;
if (i < 42) {
iec_header.B.channel = ch+1;
c = (iec_header.U >> i) & 0x1;
}
/* preset bit p as c */
*p++ = (b << 4) | (c << 2) | (c << 3);
}
}
}
/*
* FIXME: Disable NEON Optimization in hdmi, or it will cause crash of
* pulseaudio in the userspace. There is no issue for the Optimization
* implemenation, if only use "VPUSH, VPOP" in the function, the pulseaudio
* will crash also. So for my assumption, we can't use the NEON in the
* interrupt.(tasklet is implemented by softirq.)
* Disable SMP, preempt, change the dma buffer to nocached, add protection of
* Dn register and fpscr, all these operation have no effect to the result.
*/
#define HDMI_DMA_NO_NEON
#ifdef HDMI_DMA_NO_NEON
/* Optimization for IEC head */
static void hdmi_dma_copy_16_c_lut(u16 *src, u32 *dst, int samples,
u8 *lookup_table)
{
u32 sample, head, p;
int i;
for (i = 0; i < samples; i++) {
/* get source sample */
sample = *src++;
/* xor every bit */
p = sample ^ (sample >> 8);
p ^= (p >> 4);
p ^= (p >> 2);
p ^= (p >> 1);
p &= 1; /* only want last bit */
p <<= 3; /* bit p */
/* get packet header */
head = *lookup_table++;
/* fix head */
head ^= p;
/* store */
*dst++ = (head << 24) | (sample << 8);
}
}
static void hdmi_dma_copy_16_c_fast(u16 *src, u32 *dst, int samples)
{
u32 sample, p;
int i;
for (i = 0; i < samples; i++) {
/* get source sample */
sample = *src++;
/* xor every bit */
p = sample ^ (sample >> 8);
p ^= (p >> 4);
p ^= (p >> 2);
p ^= (p >> 1);
p &= 1; /* only want last bit */
p <<= 3; /* bit p */
/* store */
*dst++ = (p << 24) | (sample << 8);
}
}
static void hdmi_dma_copy_16(u16 *src, u32 *dst, int framecnt, int channelcnt)
{
/* split input frames into 192-frame each */
int count_in_192 = (framecnt + 191) / 192;
int i;
for (i = 0; i < count_in_192; i++) {
int count, samples;
/* handles frame index [0, 48) */
count = (framecnt < 48) ? framecnt : 48;
samples = count * channelcnt;
hdmi_dma_copy_16_c_lut(src, dst, samples, g_packet_head_table);
framecnt -= count;
if (framecnt == 0)
break;
src += samples;
dst += samples;
/* handles frame index [48, 192) */
count = (framecnt < 192 - 48) ? framecnt : 192 - 48;
samples = count * channelcnt;
hdmi_dma_copy_16_c_fast(src, dst, samples);
framecnt -= count;
src += samples;
dst += samples;
}
}
#else
/* NEON optimization for IEC head*/
/**
* Convert pcm samples to iec samples suitable for HDMI transfer.
* PCM sample is 16 bits length.
* Frame index always starts from 0.
* Channel count can be 1, 2, 4, 6, or 8
* Sample count (frame_count * channel_count) is multipliable by 8.
*/
static void hdmi_dma_copy_16(u16 *src, u32 *dst, int framecount, int channelcount)
{
/* split input frames into 192-frame each */
int i, count_in_192 = (framecount + 191) / 192;
for (i = 0; i < count_in_192; i++) {
int count, samples;
/* handles frame index [0, 48) */
count = (framecount < 48) ? framecount : 48;
samples = count * channelcount;
hdmi_dma_copy_16_neon_lut(src, dst, samples, g_packet_head_table);
framecount -= count;
if (framecount == 0)
break;
src += samples;
dst += samples;
/* handles frame index [48, 192) */
count = (framecount < 192 - 48) ? framecount : (192 - 48);
samples = count * channelcount;
hdmi_dma_copy_16_neon_fast(src, dst, samples);
framecount -= count;
src += samples;
dst += samples;
}
}
#endif
static void hdmi_dma_mmap_copy(struct snd_pcm_substream *substream,
int offset, int count)
{
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct snd_pcm_runtime *runtime = substream->runtime;
struct hdmi_dma_priv *priv = runtime->private_data;
struct device *dev = rtd->platform->dev;
u32 framecount, *dst;
u16 *src16;
framecount = count / (priv->sample_align * priv->channels);
/* hw_buffer is the destination for pcm data plus frame info. */
dst = (u32 *)(priv->hw_buffer.area + (offset * priv->buffer_ratio));
switch (priv->format) {
case SNDRV_PCM_FORMAT_S16_LE:
/* dma_buffer is the mmapped buffer we are copying pcm from. */
src16 = (u16 *)(runtime->dma_area + offset);
hdmi_dma_copy_16(src16, dst, framecount, priv->channels);
break;
default:
dev_err(dev, "unsupported sample format %s\n",
snd_pcm_format_name(priv->format));
return;
}
}
static void hdmi_dma_data_copy(struct snd_pcm_substream *substream,
struct hdmi_dma_priv *priv, char type)
{
struct snd_pcm_runtime *runtime = substream->runtime;
unsigned long offset, count, appl_bytes, space_to_end;
if (runtime->access != SNDRV_PCM_ACCESS_MMAP_INTERLEAVED)
return;
appl_bytes = runtime->status->hw_ptr * (runtime->frame_bits / 8);
if (type == 'p')
appl_bytes += 2 * priv->period_bytes;
offset = appl_bytes % priv->buffer_bytes;
switch (type) {
case 'p':
count = priv->period_bytes;
space_to_end = priv->period_bytes;
break;
case 'b':
count = priv->buffer_bytes;
space_to_end = priv->buffer_bytes - offset;
break;
default:
return;
}
if (count <= space_to_end) {
hdmi_dma_mmap_copy(substream, offset, count);
} else {
hdmi_dma_mmap_copy(substream, offset, space_to_end);
hdmi_dma_mmap_copy(substream, 0, count - space_to_end);
}
}
static void hdmi_sdma_callback(void *data)
{
struct hdmi_dma_priv *priv = (struct hdmi_dma_priv *)data;
struct snd_pcm_substream *substream = priv->substream;
struct snd_pcm_runtime *runtime = substream->runtime;
unsigned long flags;
spin_lock_irqsave(&priv->irq_lock, flags);
if (runtime && runtime->dma_area && priv->tx_active) {
priv->offset += priv->period_bytes;
priv->offset %= priv->period_bytes * priv->periods;
/* Copy data by period_bytes */
hdmi_dma_data_copy(substream, priv, 'p');
snd_pcm_period_elapsed(substream);
}
spin_unlock_irqrestore(&priv->irq_lock, flags);
return;
}
static int hdmi_dma_set_thrsld_incrtype(struct device *dev, int channels)
{
u8 mask = HDMI_AHB_DMA_CONF0_BURST_MODE | HDMI_AHB_DMA_CONF0_INCR_TYPE_MASK;
u8 val = hdmi_readb(HDMI_AHB_DMA_CONF0) & ~mask;
int incr_type, threshold;
switch (hdmi_readb(HDMI_REVISION_ID)) {
case 0x0a:
incr_type = HDMI_DMA_BURST_INCR4;
if (channels == 2)
threshold = 126;
else
threshold = 124;
break;
case 0x1a:
incr_type = HDMI_DMA_BURST_INCR8;
threshold = 128;
break;
default:
dev_err(dev, "unknown hdmi controller!\n");
return -ENODEV;
}
hdmi_writeb(threshold, HDMI_AHB_DMA_THRSLD);
switch (incr_type) {
case HDMI_DMA_BURST_UNSPECIFIED_LEGNTH:
break;
case HDMI_DMA_BURST_INCR4:
val |= HDMI_AHB_DMA_CONF0_BURST_MODE;
break;
case HDMI_DMA_BURST_INCR8:
val |= HDMI_AHB_DMA_CONF0_BURST_MODE |
HDMI_AHB_DMA_CONF0_INCR8;
break;
case HDMI_DMA_BURST_INCR16:
val |= HDMI_AHB_DMA_CONF0_BURST_MODE |
HDMI_AHB_DMA_CONF0_INCR16;
break;
default:
dev_err(dev, "invalid increment type: %d!", incr_type);
return -EINVAL;
}
hdmi_writeb(val, HDMI_AHB_DMA_CONF0);
hdmi_audio_debug(dev, HDMI_AHB_DMA_THRSLD);
return 0;
}
static int hdmi_dma_configure_dma(struct device *dev, int channels)
{
u8 i, val = 0;
int ret;
if (channels <= 0 || channels > 8 || channels % 2 != 0) {
dev_err(dev, "unsupported channel number: %d\n", channels);
return -EINVAL;
}
hdmi_audio_writeb(AHB_DMA_CONF0, EN_HLOCK, 0x1);
ret = hdmi_dma_set_thrsld_incrtype(dev, channels);
if (ret)
return ret;
for (i = 0; i < channels; i += 2)
val |= 0x3 << i;
hdmi_writeb(val, HDMI_AHB_DMA_CONF1);
return 0;
}
static void hdmi_dma_init_iec_header(void)
{
iec_header.U = 0;
iec_header.B.consumer = 0; /* Consumer use */
iec_header.B.linear_pcm = 0; /* linear pcm audio */
iec_header.B.copyright = 1; /* no copyright */
iec_header.B.pre_emphasis = 0; /* 2 channels without pre-emphasis */
iec_header.B.mode = 0; /* Mode 0 */
iec_header.B.category_code = 0;
iec_header.B.source = 2; /* stereo */
iec_header.B.channel = 0;
iec_header.B.sample_freq = 0x02; /* 48 KHz */
iec_header.B.clock_acc = 0; /* Level II */
iec_header.B.word_length = 0x02; /* 16 bits */
iec_header.B.org_sample_freq = 0x0D; /* 48 KHz */
iec_header.B.cgms_a = 0; /* Copying is permitted without restriction */
}
static int hdmi_dma_update_iec_header(struct snd_pcm_substream *substream)
{
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct snd_pcm_runtime *runtime = substream->runtime;
struct hdmi_dma_priv *priv = runtime->private_data;
struct device *dev = rtd->platform->dev;
iec_header.B.source = priv->channels;
switch (priv->rate) {
case 32000:
iec_header.B.sample_freq = 0x03;
iec_header.B.org_sample_freq = 0x0C;
break;
case 44100:
iec_header.B.sample_freq = 0x00;
iec_header.B.org_sample_freq = 0x0F;
break;
case 48000:
iec_header.B.sample_freq = 0x02;
iec_header.B.org_sample_freq = 0x0D;
break;
case 88200:
iec_header.B.sample_freq = 0x08;
iec_header.B.org_sample_freq = 0x07;
break;
case 96000:
iec_header.B.sample_freq = 0x0A;
iec_header.B.org_sample_freq = 0x05;
break;
case 176400:
iec_header.B.sample_freq = 0x0C;
iec_header.B.org_sample_freq = 0x03;
break;
case 192000:
iec_header.B.sample_freq = 0x0E;
iec_header.B.org_sample_freq = 0x01;
break;
default:
dev_err(dev, "unsupported sample rate\n");
return -EFAULT;
}
switch (priv->format) {
case SNDRV_PCM_FORMAT_S16_LE:
iec_header.B.word_length = 0x02;
break;
case SNDRV_PCM_FORMAT_S24_LE:
iec_header.B.word_length = 0x0b;
break;
default:
return -EFAULT;
}
return 0;
}
/*
* The HDMI block transmits the audio data without adding any of the audio
* frame bits. So we have to copy the raw dma data from the ALSA buffer
* to the DMA buffer, adding the frame information.
*/
static int hdmi_dma_copy(struct snd_pcm_substream *substream, int channel,
snd_pcm_uframes_t pos, void __user *buf,
snd_pcm_uframes_t frames)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct hdmi_dma_priv *priv = runtime->private_data;
unsigned int count = frames_to_bytes(runtime, frames);
unsigned int pos_bytes = frames_to_bytes(runtime, pos);
u32 *hw_buf;
int subframe_idx;
u32 pcm_data;
/* Adding frame info to pcm data from userspace and copy to hw_buffer */
hw_buf = (u32 *)(priv->hw_buffer.area + (pos_bytes * priv->buffer_ratio));
while (count > 0) {
for (subframe_idx = 1 ; subframe_idx <= priv->channels ; subframe_idx++) {
if (copy_from_user(&pcm_data, buf, priv->sample_align))
return -EFAULT;
buf += priv->sample_align;
count -= priv->sample_align;
/* Save the header info to the audio dma buffer */
*hw_buf++ = hdmi_dma_add_frame_info(priv, pcm_data, subframe_idx);
}
priv->frame_idx++;
if (priv->frame_idx == 192)
priv->frame_idx = 0;
}
return 0;
}
static int hdmi_sdma_initbuf(struct device *dev, struct hdmi_dma_priv *priv)
{
struct hdmi_sdma_script *hdmi_sdma_t = priv->hdmi_sdma_t;
u32 *head, *tail, i;
if (!hdmi_sdma_t) {
dev_err(dev, "hdmi private addr invalid!!!\n");
return -EINVAL;
}
hdmi_sdma_t->control_reg_addr = HDMI_BASE_ADDR + HDMI_AHB_DMA_START;
hdmi_sdma_t->status_reg_addr = HDMI_BASE_ADDR + HDMI_IH_AHBDMAAUD_STAT0;
hdmi_sdma_t->dma_start_addr = HDMI_BASE_ADDR + HDMI_AHB_DMA_STRADDR0;
head = &hdmi_sdma_t->buffer[0];
tail = &hdmi_sdma_t->buffer[1];
for (i = 0; i < priv->sdma_params.buffer_num; i++) {
*head = priv->hw_buffer.addr + i * priv->period_bytes * priv->buffer_ratio;
*tail = *head + priv->dma_period_bytes - 1;
head += 2;
tail += 2;
}
return 0;
}
static int hdmi_sdma_config(struct snd_pcm_substream *substream,
struct hdmi_dma_priv *priv)
{
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct device *dai_dev = &priv->pdev->dev;
struct device *dev = rtd->platform->dev;
struct dma_slave_config slave_config;
int ret;
priv->dma_channel = dma_request_slave_channel(dai_dev, "tx");
if (priv->dma_channel == NULL) {
dev_err(dev, "failed to alloc dma channel\n");
return -EBUSY;
}
slave_config.direction = DMA_TRANS_NONE;
slave_config.src_addr = (dma_addr_t)priv->sdma_params.buffer_num;
slave_config.dst_addr = (dma_addr_t)priv->sdma_params.phyaddr;
ret = dmaengine_slave_config(priv->dma_channel, &slave_config);
if (ret) {
dev_err(dev, "failed to config slave dma\n");
return -EINVAL;
}
return 0;
}
static int hdmi_dma_hw_free(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct hdmi_dma_priv *priv = runtime->private_data;
if (priv->dma_channel) {
dma_release_channel(priv->dma_channel);
priv->dma_channel = NULL;
}
return 0;
}
static int hdmi_dma_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct hdmi_dma_priv *priv = runtime->private_data;
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct device *dev = rtd->platform->dev;
int ret;
priv->buffer_bytes = params_buffer_bytes(params);
priv->periods = params_periods(params);
priv->period_bytes = params_period_bytes(params);
priv->channels = params_channels(params);
priv->format = params_format(params);
priv->rate = params_rate(params);
priv->offset = 0;
priv->period_time = HZ / (priv->rate / params_period_size(params));
switch (priv->format) {
case SNDRV_PCM_FORMAT_S16_LE:
priv->buffer_ratio = 2;
priv->sample_align = 2;
priv->sample_bits = 16;
break;
case SNDRV_PCM_FORMAT_S24_LE:
/* 24 bit audio in 32 bit word */
priv->buffer_ratio = 1;
priv->sample_align = 4;
priv->sample_bits = 24;
break;
default:
dev_err(dev, "unsupported sample format: %d\n", priv->format);
return -EINVAL;
}
priv->dma_period_bytes = priv->period_bytes * priv->buffer_ratio;
priv->sdma_params.buffer_num = priv->periods;
priv->sdma_params.phyaddr = priv->phy_hdmi_sdma_t;
ret = hdmi_sdma_initbuf(dev, priv);
if (ret)
return ret;
ret = hdmi_sdma_config(substream, priv);
if (ret)
return ret;
snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
ret = hdmi_dma_configure_dma(dev, priv->channels);
if (ret)
return ret;
hdmi_dma_set_addr(priv->hw_buffer.addr, priv->dma_period_bytes);
dumppriv(dev, priv);
hdmi_dma_update_iec_header(substream);
/* Init par for mmap optimizate */
init_table(priv->channels);
priv->appl_bytes = 0;
return 0;
}
static void hdmi_dma_trigger_init(struct snd_pcm_substream *substream,
struct hdmi_dma_priv *priv)
{
unsigned long status;
priv->offset = 0;
priv->frame_idx = 0;
/* Copy data by buffer_bytes */
hdmi_dma_data_copy(substream, priv, 'b');
hdmi_audio_writeb(AHB_DMA_CONF0, SW_FIFO_RST, 0x1);
/* Delay after reset */
udelay(1);
status = hdmi_readb(HDMI_IH_AHBDMAAUD_STAT0);
hdmi_writeb(status, HDMI_IH_AHBDMAAUD_STAT0);
}
static int hdmi_dma_prepare_and_submit(struct snd_pcm_substream *substream,
struct hdmi_dma_priv *priv)
{
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct device *dev = rtd->platform->dev;
priv->desc = dmaengine_prep_dma_cyclic(priv->dma_channel, 0, 0, 0,
DMA_TRANS_NONE, 0);
if (!priv->desc) {
dev_err(dev, "failed to prepare slave dma\n");
return -EINVAL;
}
priv->desc->callback = hdmi_sdma_callback;
priv->desc->callback_param = (void *)priv;
dmaengine_submit(priv->desc);
return 0;
}
static int hdmi_dma_trigger(struct snd_pcm_substream *substream, int cmd)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct hdmi_dma_priv *priv = runtime->private_data;
struct device *dev = rtd->platform->dev;
int ret;
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
case SNDRV_PCM_TRIGGER_RESUME:
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
if (!check_hdmi_state())
return 0;
hdmi_dma_trigger_init(substream, priv);
dumpregs(dev);
priv->tx_active = true;
hdmi_audio_writeb(AHB_DMA_START, START, 0x1);
hdmi_dma_irq_set(false);
hdmi_set_dma_mode(1);
ret = hdmi_dma_prepare_and_submit(substream, priv);
if (ret)
return ret;
dma_async_issue_pending(priv->desc->chan);
break;
case SNDRV_PCM_TRIGGER_STOP:
case SNDRV_PCM_TRIGGER_SUSPEND:
case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
dmaengine_terminate_all(priv->dma_channel);
hdmi_set_dma_mode(0);
hdmi_dma_irq_set(true);
hdmi_audio_writeb(AHB_DMA_STOP, STOP, 0x1);
priv->tx_active = false;
break;
default:
return -EINVAL;
}
return 0;
}
static snd_pcm_uframes_t hdmi_dma_pointer(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct hdmi_dma_priv *priv = runtime->private_data;
return bytes_to_frames(runtime, priv->offset);
}
static struct snd_pcm_hardware snd_imx_hardware = {
.info = SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_BLOCK_TRANSFER |
SNDRV_PCM_INFO_MMAP |
SNDRV_PCM_INFO_MMAP_VALID |
SNDRV_PCM_INFO_PAUSE |
SNDRV_PCM_INFO_RESUME,
.formats = MXC_HDMI_FORMATS_PLAYBACK,
.rate_min = 32000,
.channels_min = 2,
.channels_max = 8,
.buffer_bytes_max = HDMI_PCM_BUF_SIZE,
.period_bytes_min = HDMI_DMA_PERIOD_BYTES / 2,
.period_bytes_max = HDMI_DMA_PERIOD_BYTES / 2,
.periods_min = 8,
.periods_max = 8,
.fifo_size = 0,
};
static void hdmi_dma_irq_enable(struct hdmi_dma_priv *priv)
{
unsigned long flags;
hdmi_writeb(0xff, HDMI_AHB_DMA_POL);
hdmi_writeb(0xff, HDMI_AHB_DMA_BUFFPOL);
spin_lock_irqsave(&priv->irq_lock, flags);
hdmi_writeb(0xff, HDMI_IH_AHBDMAAUD_STAT0);
hdmi_writeb(0xff, HDMI_IH_MUTE_AHBDMAAUD_STAT0);
hdmi_dma_irq_set(false);
hdmi_mask(0);
spin_unlock_irqrestore(&priv->irq_lock, flags);
}
static void hdmi_dma_irq_disable(struct hdmi_dma_priv *priv)
{
unsigned long flags;
spin_lock_irqsave(&priv->irq_lock, flags);
hdmi_dma_irq_set(true);
hdmi_writeb(0x0, HDMI_IH_MUTE_AHBDMAAUD_STAT0);
hdmi_writeb(0xff, HDMI_IH_AHBDMAAUD_STAT0);
hdmi_mask(1);
spin_unlock_irqrestore(&priv->irq_lock, flags);
}
static int hdmi_dma_open(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct device *dev = rtd->platform->dev;
struct hdmi_dma_priv *priv = dev_get_drvdata(dev);
int ret;
runtime->private_data = priv;
ret = mxc_hdmi_register_audio(substream);
if (ret < 0) {
dev_err(dev, "HDMI Video is not ready!\n");
return ret;
}
hdmi_audio_writeb(AHB_DMA_CONF0, SW_FIFO_RST, 0x1);
ret = snd_pcm_hw_constraint_integer(substream->runtime,
SNDRV_PCM_HW_PARAM_PERIODS);
if (ret < 0)
return ret;
snd_soc_set_runtime_hwparams(substream, &snd_imx_hardware);
hdmi_dma_irq_enable(priv);
return 0;
}
static int hdmi_dma_close(struct snd_pcm_substream *substream)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct hdmi_dma_priv *priv = runtime->private_data;
hdmi_dma_irq_disable(priv);
mxc_hdmi_unregister_audio(substream);
return 0;
}
static struct snd_pcm_ops imx_hdmi_dma_pcm_ops = {
.open = hdmi_dma_open,
.close = hdmi_dma_close,
.ioctl = snd_pcm_lib_ioctl,
.hw_params = hdmi_dma_hw_params,
.hw_free = hdmi_dma_hw_free,
.trigger = hdmi_dma_trigger,
.pointer = hdmi_dma_pointer,
.copy = hdmi_dma_copy,
};
static int imx_hdmi_dma_pcm_new(struct snd_soc_pcm_runtime *rtd)
{
struct hdmi_dma_priv *priv = dev_get_drvdata(rtd->platform->dev);
struct snd_card *card = rtd->card->snd_card;
struct snd_pcm_substream *substream;
struct snd_pcm *pcm = rtd->pcm;
u64 dma_mask = DMA_BIT_MASK(32);
int ret = 0;
if (!card->dev->dma_mask)
card->dev->dma_mask = &dma_mask;
if (!card->dev->coherent_dma_mask)
card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, pcm->card->dev,
HDMI_PCM_BUF_SIZE, &substream->dma_buffer);
if (ret) {
dev_err(card->dev, "failed to alloc playback dma buffer\n");
return ret;
}
priv->substream = substream;
/* Alloc the hw_buffer */
ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, pcm->card->dev,
HDMI_DMA_BUF_SIZE, &priv->hw_buffer);
if (ret) {
dev_err(card->dev, "failed to alloc hw dma buffer\n");
return ret;
}
return ret;
}
static void imx_hdmi_dma_pcm_free(struct snd_pcm *pcm)
{
int stream = SNDRV_PCM_STREAM_PLAYBACK;
struct snd_pcm_substream *substream = pcm->streams[stream].substream;
struct snd_soc_pcm_runtime *rtd = pcm->private_data;
struct hdmi_dma_priv *priv = dev_get_drvdata(rtd->platform->dev);
if (substream) {
snd_dma_free_pages(&substream->dma_buffer);
substream->dma_buffer.area = NULL;
substream->dma_buffer.addr = 0;
}
/* Free the hw_buffer */
snd_dma_free_pages(&priv->hw_buffer);
priv->hw_buffer.area = NULL;
priv->hw_buffer.addr = 0;
}
static struct snd_soc_platform_driver imx_hdmi_platform = {
.ops = &imx_hdmi_dma_pcm_ops,
.pcm_new = imx_hdmi_dma_pcm_new,
.pcm_free = imx_hdmi_dma_pcm_free,
};
static int imx_soc_platform_probe(struct platform_device *pdev)
{
struct imx_hdmi *hdmi_drvdata = platform_get_drvdata(pdev);
struct hdmi_dma_priv *priv;
int ret = 0;
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
if (!priv) {
dev_err(&pdev->dev, "Failed to alloc hdmi_dma\n");
return -ENOMEM;
}
priv->hdmi_sdma_t = dma_alloc_coherent(NULL,
sizeof(struct hdmi_sdma_script),
&priv->phy_hdmi_sdma_t, GFP_KERNEL);
if (!priv->hdmi_sdma_t) {
dev_err(&pdev->dev, "Failed to alloc hdmi_sdma_t\n");
return -ENOMEM;
}
priv->tx_active = false;
spin_lock_init(&priv->irq_lock);
priv->pdev = hdmi_drvdata->pdev;
hdmi_dma_init_iec_header();
dev_set_drvdata(&pdev->dev, priv);
switch (hdmi_readb(HDMI_REVISION_ID)) {
case 0x0a:
snd_imx_hardware.period_bytes_max = HDMI_DMA_PERIOD_BYTES / 4;
snd_imx_hardware.period_bytes_min = HDMI_DMA_PERIOD_BYTES / 4;
break;
default:
break;
}
ret = snd_soc_register_platform(&pdev->dev, &imx_hdmi_platform);
if (ret)
goto err_plat;
return 0;
err_plat:
dma_free_coherent(NULL, sizeof(struct hdmi_sdma_script),
priv->hdmi_sdma_t, priv->phy_hdmi_sdma_t);
return ret;
}
static int imx_soc_platform_remove(struct platform_device *pdev)
{
struct hdmi_dma_priv *priv = dev_get_drvdata(&pdev->dev);
dma_free_coherent(NULL, sizeof(struct hdmi_sdma_script),
priv->hdmi_sdma_t, priv->phy_hdmi_sdma_t);
snd_soc_unregister_platform(&pdev->dev);
return 0;
}
static struct platform_driver imx_hdmi_dma_driver = {
.driver = {
.name = "imx-hdmi-audio",
.owner = THIS_MODULE,
},
.probe = imx_soc_platform_probe,
.remove = imx_soc_platform_remove,
};
module_platform_driver(imx_hdmi_dma_driver);
MODULE_AUTHOR("Freescale Semiconductor, Inc.");
MODULE_DESCRIPTION("i.MX HDMI audio DMA");
MODULE_LICENSE("GPL");