sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
664927c86e
nuttx/drivers/audio/audio_dma.c
Manish Kumar Sharma 6a1abbcf56 driver/audio: remove unnecessary switch in switch 
- There is unnecessary switch inside switch which is making code not too readable

Signed-off-by: Manish Kumar Sharma <manishsharma3134@gmail.com>
2023-07-16 16:40:34 +08:00

599 lines
17 KiB
C
Raw Blame History

/****************************************************************************
* drivers/audio/audio_dma.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <nuttx/audio/audio_dma.h>
#include <nuttx/kmalloc.h>
#include <nuttx/queue.h>
#include <debug.h>
/****************************************************************************
* Private Types
****************************************************************************/
struct audio_dma_s
{
struct audio_lowerhalf_s dev;
struct dma_chan_s *chan;
uintptr_t src_addr;
uintptr_t dst_addr;
uint8_t *alloc_addr;
uint8_t alloc_index;
uint8_t fifo_width;
bool playback;
bool xrun;
struct dq_queue_s pendq;
apb_samp_t buffer_size;
apb_samp_t buffer_num;
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
static int audio_dma_getcaps(struct audio_lowerhalf_s *dev, int type,
struct audio_caps_s *caps);
static int audio_dma_shutdown(struct audio_lowerhalf_s *dev);
#ifdef CONFIG_AUDIO_MULTI_SESSION
static int audio_dma_configure(struct audio_lowerhalf_s *dev,
void *session,
const struct audio_caps_s *caps);
static int audio_dma_start(struct audio_lowerhalf_s *dev,
void *session);
#ifndef CONFIG_AUDIO_EXCLUDE_STOP
static int audio_dma_stop(struct audio_lowerhalf_s *dev, void *session);
#endif
#ifndef CONFIG_AUDIO_EXCLUDE_PAUSE_RESUME
static int audio_dma_pause(struct audio_lowerhalf_s *dev,
void *session);
static int audio_dma_resume(struct audio_lowerhalf_s *dev,
void *session);
#endif
static int audio_dma_reserve(struct audio_lowerhalf_s *dev,
void **session);
static int audio_dma_release(struct audio_lowerhalf_s *dev,
void *session);
#else
static int audio_dma_configure(struct audio_lowerhalf_s *dev,
const struct audio_caps_s *caps);
static int audio_dma_start(struct audio_lowerhalf_s *dev);
#ifndef CONFIG_AUDIO_EXCLUDE_STOP
static int audio_dma_stop(struct audio_lowerhalf_s *dev);
#endif
#ifndef CONFIG_AUDIO_EXCLUDE_PAUSE_RESUME
static int audio_dma_pause(struct audio_lowerhalf_s *dev);
static int audio_dma_resume(struct audio_lowerhalf_s *dev);
#endif
static int audio_dma_reserve(struct audio_lowerhalf_s *dev);
static int audio_dma_release(struct audio_lowerhalf_s *dev);
#endif
static int audio_dma_allocbuffer(struct audio_lowerhalf_s *dev,
struct audio_buf_desc_s *bufdesc);
static int audio_dma_freebuffer(struct audio_lowerhalf_s *dev,
struct audio_buf_desc_s *bufdesc);
static int audio_dma_enqueuebuffer(struct audio_lowerhalf_s *dev,
struct ap_buffer_s *apb);
static int audio_dma_ioctl(struct audio_lowerhalf_s *dev, int cmd,
unsigned long arg);
static void audio_dma_callback(struct dma_chan_s *chan, void *arg,
ssize_t len);
/****************************************************************************
* Private Data
****************************************************************************/
static const struct audio_ops_s g_audio_dma_ops =
{
.getcaps = audio_dma_getcaps,
.configure = audio_dma_configure,
.shutdown = audio_dma_shutdown,
.start = audio_dma_start,
#ifndef CONFIG_AUDIO_EXCLUDE_STOP
.stop = audio_dma_stop,
#endif
#ifndef CONFIG_AUDIO_EXCLUDE_PAUSE_RESUME
.pause = audio_dma_pause,
.resume = audio_dma_resume,
#endif
.allocbuffer = audio_dma_allocbuffer,
.freebuffer = audio_dma_freebuffer,
.enqueuebuffer = audio_dma_enqueuebuffer,
.ioctl = audio_dma_ioctl,
.reserve = audio_dma_reserve,
.release = audio_dma_release,
};
/****************************************************************************
* Private Functions
****************************************************************************/
static int audio_dma_getcaps(struct audio_lowerhalf_s *dev, int type,
struct audio_caps_s *caps)
{
struct audio_dma_s *audio_dma = (struct audio_dma_s *)dev;
/* Validate the structure */
DEBUGASSERT(caps && caps->ac_len >= sizeof(struct audio_caps_s));
audinfo("type=%d ac_type=%d\n", type, caps->ac_type);
/* Fill in the caller's structure based on requested info */
caps->ac_format.hw = 0;
caps->ac_controls.w = 0;
switch (caps->ac_type)
{
/* Caller is querying for the types of units we support */
case AUDIO_TYPE_QUERY:
/* Provide our overall capabilities. The interfacing software
* must then call us back for specific info for each capability.
*/
caps->ac_channels = 2; /* Stereo output */
if (caps->ac_subtype == AUDIO_TYPE_QUERY)
{
/* We don't decode any formats! Only something above us in
* the audio stream can perform decoding on our behalf.
*/
/* The types of audio units we implement */
if (audio_dma->playback)
{
caps->ac_controls.b[0] = AUDIO_TYPE_OUTPUT;
}
else
{
caps->ac_controls.b[0] = AUDIO_TYPE_INPUT;
}
caps->ac_format.hw = 1 << (AUDIO_FMT_PCM - 1);
}
caps->ac_controls.b[0] = AUDIO_SUBFMT_END;
break;
/* Provide capabilities of our OUTPUT unit */
case AUDIO_TYPE_OUTPUT:
case AUDIO_TYPE_INPUT:
caps->ac_channels = 2;
if (caps->ac_subtype == AUDIO_TYPE_QUERY)
{
/* Report the Sample rates we support */
caps->ac_controls.hw[0] = AUDIO_SAMP_RATE_DEF_ALL;
}
break;
}
/* Return the length of the audio_caps_s struct for validation of
* proper Audio device type.
*/
return caps->ac_len;
}
#ifdef CONFIG_AUDIO_MULTI_SESSION
static int audio_dma_configure(struct audio_lowerhalf_s *dev,
void *session,
const struct audio_caps_s *caps)
#else
static int audio_dma_configure(struct audio_lowerhalf_s *dev,
const struct audio_caps_s *caps)
#endif
{
struct audio_dma_s *audio_dma = (struct audio_dma_s *)dev;
struct dma_config_s cfg;
int ret = -EINVAL;
DEBUGASSERT(audio_dma && caps);
audinfo("ac_type: %d\n", caps->ac_type);
/* Process the configure operation */
switch (caps->ac_type)
{
case AUDIO_TYPE_OUTPUT:
if (audio_dma->playback)
{
memset(&cfg, 0, sizeof(struct dma_config_s));
cfg.direction = DMA_MEM_TO_DEV;
if (audio_dma->fifo_width)
cfg.dst_width = audio_dma->fifo_width;
else
cfg.dst_width = caps->ac_controls.b[2] / 8;
ret = DMA_CONFIG(audio_dma->chan, &cfg);
}
break;
case AUDIO_TYPE_INPUT:
if (!audio_dma->playback)
{
memset(&cfg, 0, sizeof(struct dma_config_s));
cfg.direction = DMA_DEV_TO_MEM;
if (audio_dma->fifo_width)
cfg.src_width = audio_dma->fifo_width;
else
cfg.src_width = caps->ac_controls.b[2] / 8;
ret = DMA_CONFIG(audio_dma->chan, &cfg);
}
break;
default:
ret = -ENOTTY;
break;
}
return ret;
}
static int audio_dma_shutdown(struct audio_lowerhalf_s *dev)
{
/* apps enqueued buffers, but doesn't start. stop here to
* clear audio_dma->pendq.
*/
#ifndef CONFIG_AUDIO_EXCLUDE_STOP
#ifdef CONFIG_AUDIO_MULTI_SESSION
audio_dma_stop(dev, NULL);
#else
audio_dma_stop(dev);
#endif
#endif
return OK;
}
#ifdef CONFIG_AUDIO_MULTI_SESSION
static int audio_dma_start(struct audio_lowerhalf_s *dev, void *session)
#else
static int audio_dma_start(struct audio_lowerhalf_s *dev)
#endif
{
struct audio_dma_s *audio_dma = (struct audio_dma_s *)dev;
return DMA_START_CYCLIC(audio_dma->chan, audio_dma_callback, audio_dma,
audio_dma->dst_addr, audio_dma->src_addr,
audio_dma->buffer_num * audio_dma->buffer_size,
audio_dma->buffer_size);
}
#ifndef CONFIG_AUDIO_EXCLUDE_STOP
#ifdef CONFIG_AUDIO_MULTI_SESSION
static int audio_dma_stop(struct audio_lowerhalf_s *dev, void *session)
#else
static int audio_dma_stop(struct audio_lowerhalf_s *dev)
#endif
{
struct audio_dma_s *audio_dma = (struct audio_dma_s *)dev;
struct ap_buffer_s *apb;
DMA_STOP(audio_dma->chan);
while (!dq_empty(&audio_dma->pendq))
{
apb = (struct ap_buffer_s *)dq_remfirst(&audio_dma->pendq);
#ifdef CONFIG_AUDIO_MULTI_SESSION
audio_dma->dev.upper(audio_dma->dev.priv, AUDIO_CALLBACK_DEQUEUE,
apb, OK, NULL);
#else
audio_dma->dev.upper(audio_dma->dev.priv, AUDIO_CALLBACK_DEQUEUE,
apb, OK);
#endif
}
#ifdef CONFIG_AUDIO_MULTI_SESSION
audio_dma->dev.upper(audio_dma->dev.priv, AUDIO_CALLBACK_COMPLETE,
NULL, OK, NULL);
#else
audio_dma->dev.upper(audio_dma->dev.priv, AUDIO_CALLBACK_COMPLETE,
NULL, OK);
#endif
audio_dma->xrun = false;
return OK;
}
#endif
#ifndef CONFIG_AUDIO_EXCLUDE_PAUSE_RESUME
#ifdef CONFIG_AUDIO_MULTI_SESSION
static int audio_dma_pause(struct audio_lowerhalf_s *dev, void *session)
#else
static int audio_dma_pause(struct audio_lowerhalf_s *dev)
#endif
{
struct audio_dma_s *audio_dma = (struct audio_dma_s *)dev;
return DMA_PAUSE(audio_dma->chan);
}
#ifdef CONFIG_AUDIO_MULTI_SESSION
static int audio_dma_resume(struct audio_lowerhalf_s *dev, void *session)
#else
static int audio_dma_resume(struct audio_lowerhalf_s *dev)
#endif
{
struct audio_dma_s *audio_dma = (struct audio_dma_s *)dev;
if (dq_empty(&audio_dma->pendq))
{
return -EINVAL;
}
return DMA_RESUME(audio_dma->chan);
}
#endif
static int audio_dma_allocbuffer(struct audio_lowerhalf_s *dev,
struct audio_buf_desc_s *bufdesc)
{
struct audio_dma_s *audio_dma = (struct audio_dma_s *)dev;
struct ap_buffer_s *apb;
if (bufdesc->numbytes != audio_dma->buffer_size)
{
return -EINVAL;
}
if (audio_dma->alloc_index == audio_dma->buffer_num)
{
return -ENOMEM;
}
if (!audio_dma->alloc_addr)
{
audio_dma->alloc_addr = kumm_memalign(32,
audio_dma->buffer_num *
audio_dma->buffer_size);
if (!audio_dma->alloc_addr)
{
return -ENOMEM;
}
if (audio_dma->playback)
audio_dma->src_addr = up_addrenv_va_to_pa(audio_dma->alloc_addr);
else
audio_dma->dst_addr = up_addrenv_va_to_pa(audio_dma->alloc_addr);
}
apb = kumm_zalloc(sizeof(struct ap_buffer_s));
*bufdesc->u.pbuffer = apb;
/* Test if the allocation was successful or not */
if (*bufdesc->u.pbuffer == NULL)
{
return -ENOMEM;
}
/* Populate the buffer contents */
apb->i.channels = 2;
apb->crefs = 1;
apb->nmaxbytes = audio_dma->buffer_size;
apb->samp = audio_dma->alloc_addr +
audio_dma->alloc_index *
audio_dma->buffer_size;
audio_dma->alloc_index++;
nxmutex_init(&apb->lock);
return sizeof(struct audio_buf_desc_s);
}
static int audio_dma_freebuffer(struct audio_lowerhalf_s *dev,
struct audio_buf_desc_s *bufdesc)
{
struct audio_dma_s *audio_dma = (struct audio_dma_s *)dev;
struct ap_buffer_s *apb;
apb = bufdesc->u.buffer;
audio_dma->alloc_index--;
nxmutex_destroy(&apb->lock);
kumm_free(apb);
if (audio_dma->alloc_index == 0)
{
kumm_free(audio_dma->alloc_addr);
audio_dma->alloc_addr = NULL;
}
return sizeof(struct audio_buf_desc_s);
}
static int audio_dma_enqueuebuffer(struct audio_lowerhalf_s *dev,
struct ap_buffer_s *apb)
{
struct audio_dma_s *audio_dma = (struct audio_dma_s *)dev;
irqstate_t flags;
if (audio_dma->playback)
up_clean_dcache((uintptr_t)apb->samp,
(uintptr_t)apb->samp + apb->nbytes);
apb->flags |= AUDIO_APB_OUTPUT_ENQUEUED;
flags = enter_critical_section();
dq_addlast(&apb->dq_entry, &audio_dma->pendq);
leave_critical_section(flags);
if (audio_dma->xrun)
{
audio_dma->xrun = false;
return audio_dma_resume(dev);
}
return OK;
}
static int audio_dma_ioctl(struct audio_lowerhalf_s *dev, int cmd,
unsigned long arg)
{
struct audio_dma_s *audio_dma = (struct audio_dma_s *)dev;
struct ap_buffer_info_s *bufinfo;
switch (cmd)
{
/* Report our preferred buffer size and quantity */
case AUDIOIOC_GETBUFFERINFO:
audinfo("AUDIOIOC_GETBUFFERINFO:\n");
bufinfo = (struct ap_buffer_info_s *)arg;
bufinfo->buffer_size = audio_dma->buffer_size;
bufinfo->nbuffers = audio_dma->buffer_num;
return OK;
case AUDIOIOC_SETBUFFERINFO:
audinfo("AUDIOIOC_GETBUFFERINFO:\n");
bufinfo = (struct ap_buffer_info_s *)arg;
audio_dma->buffer_size = bufinfo->buffer_size;
audio_dma->buffer_num = bufinfo->nbuffers;
kumm_free(audio_dma->alloc_addr);
audio_dma->alloc_addr = NULL;
audio_dma->alloc_index = 0;
return OK;
}
return -ENOTTY;
}
#ifdef CONFIG_AUDIO_MULTI_SESSION
static int audio_dma_reserve(struct audio_lowerhalf_s *dev, void **session)
#else
static int audio_dma_reserve(struct audio_lowerhalf_s *dev)
#endif
{
return OK;
}
#ifdef CONFIG_AUDIO_MULTI_SESSION
static int audio_dma_release(struct audio_lowerhalf_s *dev, void *session)
#else
static int audio_dma_release(struct audio_lowerhalf_s *dev)
#endif
{
return OK;
}
static void audio_dma_callback(struct dma_chan_s *chan,
void *arg, ssize_t len)
{
struct audio_dma_s *audio_dma = (struct audio_dma_s *)arg;
struct ap_buffer_s *apb;
bool final = false;
apb = (struct ap_buffer_s *)dq_remfirst(&audio_dma->pendq);
if (!apb)
{
/* xrun */
DMA_PAUSE(audio_dma->chan);
audio_dma->xrun = true;
return;
}
if (!audio_dma->playback)
up_invalidate_dcache((uintptr_t)apb->samp,
(uintptr_t)apb->samp + apb->nbytes);
if ((apb->flags & AUDIO_APB_FINAL) != 0)
final = true;
#ifdef CONFIG_AUDIO_MULTI_SESSION
audio_dma->dev.upper(audio_dma->dev.priv, AUDIO_CALLBACK_DEQUEUE,
apb, OK, NULL);
#else
audio_dma->dev.upper(audio_dma->dev.priv, AUDIO_CALLBACK_DEQUEUE,
apb, OK);
#endif
if (final)
{
#ifdef CONFIG_AUDIO_MULTI_SESSION
audio_dma_stop(&audio_dma->dev, NULL);
#else
audio_dma_stop(&audio_dma->dev);
#endif
}
else if (dq_empty(&audio_dma->pendq))
{
/* xrun */
DMA_PAUSE(audio_dma->chan);
audio_dma->xrun = true;
}
}
/****************************************************************************
* Public Functions
****************************************************************************/
struct audio_lowerhalf_s *audio_dma_initialize(struct dma_dev_s *dma_dev,
uint8_t chan_num,
bool playback,
uint8_t fifo_width,
uintptr_t fifo_addr)
{
struct audio_dma_s *audio_dma;
if (!dma_dev)
{
return NULL;
}
audio_dma = kmm_zalloc(sizeof(struct audio_dma_s));
if (!audio_dma)
{
return NULL;
}
audio_dma->chan = DMA_GET_CHAN(dma_dev, chan_num);
if (!audio_dma->chan)
{
kmm_free(audio_dma);
return NULL;
}
audio_dma->playback = playback;
audio_dma->fifo_width = fifo_width;
if (audio_dma->playback)
audio_dma->dst_addr = up_addrenv_va_to_pa((void *)fifo_addr);
else
audio_dma->src_addr = up_addrenv_va_to_pa((void *)fifo_addr);
audio_dma->buffer_size = CONFIG_AUDIO_BUFFER_NUMBYTES;
audio_dma->buffer_num = CONFIG_AUDIO_NUM_BUFFERS;
dq_init(&audio_dma->pendq);
audio_dma->dev.ops = &g_audio_dma_ops;
return &audio_dma->dev;
}
Reference in New Issue View Git Blame Copy Permalink