e25505daa4
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@19620 a1c6a512-1295-4272-9138-f99709370657
400 lines
10 KiB
C
400 lines
10 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2008 by Michael Sevakis
|
|
*
|
|
* 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
****************************************************************************/
|
|
#include <stdlib.h>
|
|
#include "system.h"
|
|
#include "kernel.h"
|
|
#include "audio.h"
|
|
#include "sound.h"
|
|
#include "avic-imx31.h"
|
|
#include "clkctl-imx31.h"
|
|
|
|
/* This isn't DMA-based at the moment and is handled like Portal Player but
|
|
* will suffice for starters. */
|
|
|
|
struct dma_data
|
|
{
|
|
uint16_t *p;
|
|
size_t size;
|
|
int locked;
|
|
int state;
|
|
};
|
|
|
|
static struct dma_data dma_play_data =
|
|
{
|
|
/* Initialize to a locked, stopped state */
|
|
.p = NULL,
|
|
.size = 0,
|
|
.locked = 0,
|
|
.state = 0
|
|
};
|
|
|
|
void pcm_play_lock(void)
|
|
{
|
|
if (++dma_play_data.locked == 1)
|
|
{
|
|
/* Atomically disable transmit interrupt */
|
|
imx31_regclr32(&SSI_SIER1, SSI_SIER_TIE);
|
|
}
|
|
}
|
|
|
|
void pcm_play_unlock(void)
|
|
{
|
|
if (--dma_play_data.locked == 0 && dma_play_data.state != 0)
|
|
{
|
|
/* Atomically enable transmit interrupt */
|
|
imx31_regset32(&SSI_SIER1, SSI_SIER_TIE);
|
|
}
|
|
}
|
|
|
|
static void __attribute__((interrupt("IRQ"))) SSI1_HANDLER(void)
|
|
{
|
|
register pcm_more_callback_type get_more;
|
|
|
|
do
|
|
{
|
|
while (dma_play_data.size > 0)
|
|
{
|
|
if (SSI_SFCSR_TFCNT0r(SSI_SFCSR1) > 6)
|
|
{
|
|
return;
|
|
}
|
|
SSI_STX0_1 = *dma_play_data.p++;
|
|
SSI_STX0_1 = *dma_play_data.p++;
|
|
dma_play_data.size -= 4;
|
|
}
|
|
|
|
/* p is empty, get some more data */
|
|
get_more = pcm_callback_for_more;
|
|
|
|
if (get_more)
|
|
{
|
|
get_more((unsigned char **)&dma_play_data.p,
|
|
&dma_play_data.size);
|
|
}
|
|
}
|
|
while (dma_play_data.size > 0);
|
|
|
|
/* No more data, so disable the FIFO/interrupt */
|
|
pcm_play_dma_stop();
|
|
pcm_play_dma_stopped_callback();
|
|
}
|
|
|
|
void pcm_dma_apply_settings(void)
|
|
{
|
|
audiohw_set_frequency(pcm_fsel);
|
|
}
|
|
|
|
void pcm_play_dma_init(void)
|
|
{
|
|
imx31_clkctl_module_clock_gating(CG_SSI1, CGM_ON_ALL);
|
|
imx31_clkctl_module_clock_gating(CG_SSI2, CGM_ON_ALL);
|
|
|
|
/* Reset & disable SSIs */
|
|
SSI_SCR2 &= ~SSI_SCR_SSIEN;
|
|
SSI_SCR1 &= ~SSI_SCR_SSIEN;
|
|
|
|
SSI_SIER1 = SSI_SIER_TFE0; /* TX0 can issue an interrupt */
|
|
SSI_SIER2 = SSI_SIER_RFF0; /* RX0 can issue an interrupt */
|
|
|
|
/* Set up audio mux */
|
|
|
|
/* Port 1 (internally connected to SSI1)
|
|
* All clocking is output sourced from port 4 */
|
|
AUDMUX_PTCR1 = AUDMUX_PTCR_TFS_DIR | AUDMUX_PTCR_TFSEL_PORT4 |
|
|
AUDMUX_PTCR_TCLKDIR | AUDMUX_PTCR_TCSEL_PORT4 |
|
|
AUDMUX_PTCR_SYN;
|
|
|
|
/* Receive data from port 4 */
|
|
AUDMUX_PDCR1 = AUDMUX_PDCR_RXDSEL_PORT4;
|
|
/* All clock lines are inputs sourced from the master mode codec and
|
|
* sent back to SSI1 through port 1 */
|
|
AUDMUX_PTCR4 = AUDMUX_PTCR_SYN;
|
|
|
|
/* Receive data from port 1 */
|
|
AUDMUX_PDCR4 = AUDMUX_PDCR_RXDSEL_PORT1;
|
|
|
|
/* PORT2 (internally connected to SSI2) routes clocking to PORT5 to
|
|
* provide MCLK to the codec */
|
|
/* TX clocks are inputs taken from SSI2 */
|
|
/* RX clocks are outputs taken from PORT4 */
|
|
AUDMUX_PTCR2 = AUDMUX_PTCR_RFS_DIR | AUDMUX_PTCR_RFSSEL_PORT4 |
|
|
AUDMUX_PTCR_RCLKDIR | AUDMUX_PTCR_RCSEL_PORT4;
|
|
/* RX data taken from PORT4 */
|
|
AUDMUX_PDCR2 = AUDMUX_PDCR_RXDSEL_PORT4;
|
|
|
|
/* PORT5 outputs TCLK sourced from PORT2 (SSI2) */
|
|
AUDMUX_PTCR5 = AUDMUX_PTCR_TCLKDIR | AUDMUX_PTCR_TCSEL_PORT2;
|
|
AUDMUX_PDCR5 = 0;
|
|
|
|
/* Setup SSIs */
|
|
|
|
/* SSI1 - SoC software interface for all I2S data out */
|
|
SSI_SCR1 = SSI_SCR_SYN | SSI_SCR_I2S_MODE_SLAVE;
|
|
SSI_STCR1 = SSI_STCR_TXBIT0 | SSI_STCR_TSCKP | SSI_STCR_TFSI |
|
|
SSI_STCR_TEFS | SSI_STCR_TFEN0;
|
|
|
|
/* 16 bits per word, 2 words per frame */
|
|
SSI_STCCR1 = SSI_STRCCR_WL16 | SSI_STRCCR_DCw(2-1) |
|
|
SSI_STRCCR_PMw(4-1);
|
|
|
|
/* Transmit low watermark - 2 samples in FIFO */
|
|
SSI_SFCSR1 = SSI_SFCSR_TFWM1w(1) | SSI_SFCSR_TFWM0w(2);
|
|
SSI_STMSK1 = 0;
|
|
|
|
/* SSI2 - provides MCLK to codec. Receives data from codec. */
|
|
SSI_STCR2 = SSI_STCR_TXDIR;
|
|
|
|
/* f(INT_BIT_CLK) =
|
|
* f(SYS_CLK) / [(DIV2 + 1)*(7*PSR + 1)*(PM + 1)*2] =
|
|
* 677737600 / [(1 + 1)*(7*0 + 1)*(0 + 1)*2] =
|
|
* 677737600 / 4 = 169344000 Hz
|
|
*
|
|
* 45.4.2.2 DIV2, PSR, and PM Bit Description states:
|
|
* Bits DIV2, PSR, and PM should not be all set to zero at the same
|
|
* time.
|
|
*
|
|
* The hardware seems to force a divide by 4 even if all bits are
|
|
* zero but comply by setting DIV2 and the others to zero.
|
|
*/
|
|
SSI_STCCR2 = SSI_STRCCR_DIV2 | SSI_STRCCR_PMw(1-1);
|
|
|
|
/* SSI2 - receive - asynchronous clocks */
|
|
SSI_SCR2 = SSI_SCR_I2S_MODE_SLAVE;
|
|
|
|
SSI_SRCR2 = SSI_SRCR_RXBIT0 | SSI_SRCR_RSCKP | SSI_SRCR_RFSI |
|
|
SSI_SRCR_REFS;
|
|
|
|
/* 16 bits per word, 2 words per frame */
|
|
SSI_SRCCR2 = SSI_STRCCR_WL16 | SSI_STRCCR_DCw(2-1) |
|
|
SSI_STRCCR_PMw(4-1);
|
|
|
|
/* Receive high watermark - 6 samples in FIFO */
|
|
SSI_SFCSR2 = SSI_SFCSR_RFWM1w(8) | SSI_SFCSR_RFWM0w(6);
|
|
SSI_SRMSK2 = 0;
|
|
|
|
/* Enable SSI2 (codec clock) */
|
|
SSI_SCR2 |= SSI_SCR_SSIEN;
|
|
|
|
audiohw_init();
|
|
}
|
|
|
|
void pcm_postinit(void)
|
|
{
|
|
audiohw_postinit();
|
|
avic_enable_int(SSI1, IRQ, 8, SSI1_HANDLER);
|
|
}
|
|
|
|
static void play_start_pcm(void)
|
|
{
|
|
/* Stop transmission (if in progress) */
|
|
SSI_SCR1 &= ~SSI_SCR_TE;
|
|
|
|
/* Enable interrupt on unlock */
|
|
dma_play_data.state = 1;
|
|
|
|
/* Fill the FIFO or start when data is used up */
|
|
SSI_SCR1 |= SSI_SCR_SSIEN; /* Enable SSI */
|
|
SSI_STCR1 |= SSI_STCR_TFEN0; /* Enable TX FIFO */
|
|
|
|
while (1)
|
|
{
|
|
if (SSI_SFCSR_TFCNT0r(SSI_SFCSR1) > 6 || dma_play_data.size == 0)
|
|
{
|
|
SSI_SCR1 |= SSI_SCR_TE; /* Start transmitting */
|
|
return;
|
|
}
|
|
|
|
SSI_STX0_1 = *dma_play_data.p++;
|
|
SSI_STX0_1 = *dma_play_data.p++;
|
|
dma_play_data.size -= 4;
|
|
}
|
|
}
|
|
|
|
static void play_stop_pcm(void)
|
|
{
|
|
/* Disable interrupt */
|
|
SSI_SIER1 &= ~SSI_SIER_TIE;
|
|
|
|
/* Wait for FIFO to empty */
|
|
while (SSI_SFCSR_TFCNT0r(SSI_SFCSR1) > 0);
|
|
|
|
/* Disable transmission */
|
|
SSI_STCR1 &= ~SSI_STCR_TFEN0;
|
|
SSI_SCR1 &= ~(SSI_SCR_TE | SSI_SCR_SSIEN);
|
|
|
|
/* Do not enable interrupt on unlock */
|
|
dma_play_data.state = 0;
|
|
}
|
|
|
|
void pcm_play_dma_start(const void *addr, size_t size)
|
|
{
|
|
dma_play_data.p = (void *)(((uintptr_t)addr + 3) & ~3);
|
|
dma_play_data.size = (size & ~3);
|
|
|
|
play_start_pcm();
|
|
}
|
|
|
|
void pcm_play_dma_stop(void)
|
|
{
|
|
play_stop_pcm();
|
|
dma_play_data.size = 0;
|
|
}
|
|
|
|
void pcm_play_dma_pause(bool pause)
|
|
{
|
|
if (pause)
|
|
{
|
|
play_stop_pcm();
|
|
}
|
|
else
|
|
{
|
|
uint32_t addr = (uint32_t)dma_play_data.p;
|
|
dma_play_data.p = (void *)((addr + 2) & ~3);
|
|
dma_play_data.size &= ~3;
|
|
play_start_pcm();
|
|
}
|
|
}
|
|
|
|
/* Return the number of bytes waiting - full L-R sample pairs only */
|
|
size_t pcm_get_bytes_waiting(void)
|
|
{
|
|
return dma_play_data.size & ~3;
|
|
}
|
|
|
|
/* Return a pointer to the samples and the number of them in *count */
|
|
const void * pcm_play_dma_get_peak_buffer(int *count)
|
|
{
|
|
uint32_t addr = (uint32_t)dma_play_data.p;
|
|
size_t cnt = dma_play_data.size;
|
|
*count = cnt >> 2;
|
|
return (void *)((addr + 2) & ~3);
|
|
}
|
|
|
|
#ifdef HAVE_RECORDING
|
|
static struct dma_data dma_rec_data =
|
|
{
|
|
/* Initialize to a locked, stopped state */
|
|
.p = NULL,
|
|
.size = 0,
|
|
.locked = 0,
|
|
.state = 0
|
|
};
|
|
|
|
static void __attribute__((interrupt("IRQ"))) SSI2_HANDLER(void)
|
|
{
|
|
register pcm_more_callback_type2 more_ready;
|
|
|
|
while (dma_rec_data.size > 0)
|
|
{
|
|
if (SSI_SFCSR_RFCNT0r(SSI_SFCSR2) < 2)
|
|
return;
|
|
|
|
*dma_rec_data.p++ = SSI_SRX0_2;
|
|
*dma_rec_data.p++ = SSI_SRX0_2;
|
|
dma_rec_data.size -= 4;
|
|
}
|
|
|
|
more_ready = pcm_callback_more_ready;
|
|
|
|
if (more_ready == NULL || more_ready(0) < 0) {
|
|
/* Finished recording */
|
|
pcm_rec_dma_stop();
|
|
pcm_rec_dma_stopped_callback();
|
|
}
|
|
}
|
|
|
|
void pcm_rec_lock(void)
|
|
{
|
|
if (++dma_rec_data.locked == 1)
|
|
{
|
|
/* Atomically disable receive interrupt */
|
|
imx31_regclr32(&SSI_SIER2, SSI_SIER_RIE);
|
|
}
|
|
}
|
|
|
|
void pcm_rec_unlock(void)
|
|
{
|
|
if (--dma_rec_data.locked == 0 && dma_rec_data.state != 0)
|
|
{
|
|
/* Atomically enable receive interrupt */
|
|
imx31_regset32(&SSI_SIER2, SSI_SIER_RIE);
|
|
}
|
|
}
|
|
|
|
void pcm_record_more(void *start, size_t size)
|
|
{
|
|
pcm_rec_peak_addr = start; /* Start peaking at dest */
|
|
dma_rec_data.p = start; /* Start of RX buffer */
|
|
dma_rec_data.size = size; /* Bytes to transfer */
|
|
}
|
|
|
|
void pcm_rec_dma_stop(void)
|
|
{
|
|
/* Stop receiving data */
|
|
SSI_SCR2 &= ~SSI_SCR_RE; /* Disable RX */
|
|
SSI_SRCR2 &= ~SSI_SRCR_RFEN0; /* Disable RX FIFO */
|
|
|
|
dma_rec_data.state = 0;
|
|
|
|
avic_disable_int(SSI2);
|
|
}
|
|
|
|
void pcm_rec_dma_start(void *addr, size_t size)
|
|
{
|
|
pcm_rec_dma_stop();
|
|
|
|
pcm_rec_peak_addr = addr;
|
|
dma_rec_data.p = addr;
|
|
dma_rec_data.size = size;
|
|
|
|
dma_rec_data.state = 1;
|
|
|
|
avic_enable_int(SSI2, IRQ, 9, SSI2_HANDLER);
|
|
|
|
SSI_SRCR2 |= SSI_SRCR_RFEN0; /* Enable RX FIFO */
|
|
|
|
/* Ensure clear FIFO */
|
|
while (SSI_SFCSR2 & SSI_SFCSR_RFCNT0)
|
|
SSI_SRX0_2;
|
|
|
|
/* Enable receive */
|
|
SSI_SCR2 |= SSI_SCR_RE;
|
|
}
|
|
|
|
void pcm_rec_dma_close(void)
|
|
{
|
|
pcm_rec_dma_stop();
|
|
}
|
|
|
|
void pcm_rec_dma_init(void)
|
|
{
|
|
pcm_rec_dma_stop();
|
|
}
|
|
|
|
const void * pcm_rec_dma_get_peak_buffer(int *count)
|
|
{
|
|
unsigned long addr = (uint32_t)pcm_rec_peak_addr;
|
|
unsigned long end = (uint32_t)dma_rec_data.p;
|
|
*count = (end >> 2) - (addr >> 2);
|
|
return (void *)(addr & ~3);
|
|
}
|
|
|
|
#endif /* HAVE_RECORDING */
|