1242 lines
35 KiB
C
1242 lines
35 KiB
C
/****************************************************************************
|
|
* drivers/virtio/virtio-snd.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 <assert.h>
|
|
#include <debug.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <sys/param.h>
|
|
|
|
#include <nuttx/audio/audio.h>
|
|
#include <nuttx/kmalloc.h>
|
|
#include <nuttx/virtio/virtio.h>
|
|
#include <nuttx/semaphore.h>
|
|
|
|
#include "virtio-snd.h"
|
|
|
|
/****************************************************************************
|
|
* Private Types
|
|
****************************************************************************/
|
|
|
|
/* Map for converting VirtIO frame rate to nuttx frame rate */
|
|
|
|
struct virtio_snd_rate_map_s
|
|
{
|
|
unsigned int nrate;
|
|
unsigned int sps;
|
|
};
|
|
|
|
/* Map for nuttx bps to virtio pcm subformat */
|
|
|
|
struct virtio_snd_format_map_s
|
|
{
|
|
uint8_t nformat;
|
|
unsigned int bps;
|
|
};
|
|
|
|
/* Buffer for pcm data tx/rx transfer */
|
|
|
|
struct virtio_snd_buffer_s
|
|
{
|
|
struct ap_buffer_s apb;
|
|
struct virtio_snd_pcm_xfer xfer;
|
|
struct virtio_snd_pcm_status status;
|
|
FAR struct audio_lowerhalf_s *dev;
|
|
};
|
|
|
|
/* Include struct audio_lowerhalf_s, use to get struct virtio_snd_s */
|
|
|
|
struct virtio_snd_dev_s
|
|
{
|
|
struct audio_lowerhalf_s dev;
|
|
uint32_t period_bytes;
|
|
uint32_t index;
|
|
bool running;
|
|
FAR void *priv;
|
|
};
|
|
|
|
/* Virtio snd card struct for virtio driver */
|
|
|
|
struct virtio_snd_s
|
|
{
|
|
FAR struct virtio_device *vdev;
|
|
FAR struct virtio_snd_dev_s *dev;
|
|
FAR struct virtio_snd_pcm_info *info;
|
|
struct virtio_snd_config config;
|
|
};
|
|
|
|
/****************************************************************************
|
|
* Private Function Prototypes
|
|
****************************************************************************/
|
|
|
|
static void virtio_snd_pcm_notify_cb(FAR struct virtqueue *vqueue);
|
|
static void virtio_snd_ctl_notify_cb(FAR struct virtqueue *vqueue);
|
|
static void virtio_snd_event_notify_cb(FAR struct virtqueue *vqueue);
|
|
|
|
static unsigned int virtio_snd_get_period_bytes(unsigned int rate,
|
|
unsigned int ch,
|
|
unsigned int bps,
|
|
unsigned int period_time);
|
|
static unsigned int
|
|
virtio_snd_get_support_rates(FAR const struct virtio_snd_pcm_info *info);
|
|
static void
|
|
virtio_snd_get_support_formats(FAR const struct virtio_snd_pcm_info *info,
|
|
FAR struct audio_caps_s *caps);
|
|
|
|
static int virtio_snd_send_pcm(FAR struct virtio_snd_dev_s *sdev,
|
|
FAR struct virtio_snd_buffer_s *buf);
|
|
static int virtio_snd_send_ctl(FAR struct virtio_snd_s *priv,
|
|
FAR struct virtqueue_buf *vb,
|
|
int readable,
|
|
int writable);
|
|
static int virtio_snd_query_info(FAR struct virtio_snd_s *priv,
|
|
int cmd,
|
|
size_t size,
|
|
size_t count,
|
|
FAR struct virtio_snd_pcm_info *info);
|
|
static int virtio_snd_set_params(FAR struct virtio_snd_dev_s *sdev,
|
|
unsigned int ch,
|
|
unsigned int rate,
|
|
unsigned int bps);
|
|
static int virtio_snd_send_cmd(FAR struct virtio_snd_dev_s *sdev,
|
|
int cmd);
|
|
|
|
static int virtio_snd_getcaps(FAR struct audio_lowerhalf_s *dev,
|
|
int type,
|
|
FAR struct audio_caps_s *caps);
|
|
#ifdef CONFIG_AUDIO_MULTI_SESSION
|
|
static int virtio_snd_configure(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void *session,
|
|
FAR const struct audio_caps_s *caps);
|
|
static int virtio_snd_start(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void *session);
|
|
#ifndef CONFIG_AUDIO_EXCLUDE_STOP
|
|
static int virtio_snd_stop(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void *session);
|
|
#endif
|
|
#ifndef CONFIG_AUDIO_EXCLUDE_PAUSE_RESUME
|
|
static int virtio_snd_pause(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void *session);
|
|
static int virtio_snd_resume(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void *session);
|
|
#endif
|
|
static int virtio_snd_reserve(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void **session);
|
|
static int virtio_snd_release(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void *session);
|
|
#else
|
|
static int virtio_snd_configure(FAR struct audio_lowerhalf_s *dev,
|
|
FAR const struct audio_caps_s *caps);
|
|
static int virtio_snd_start(FAR struct audio_lowerhalf_s *dev);
|
|
#ifndef CONFIG_AUDIO_EXCLUDE_STOP
|
|
static int virtio_snd_stop(FAR struct audio_lowerhalf_s *dev);
|
|
#endif
|
|
#ifndef CONFIG_AUDIO_EXCLUDE_PAUSE_RESUME
|
|
static int virtio_snd_pause(FAR struct audio_lowerhalf_s *dev);
|
|
static int virtio_snd_resume(FAR struct audio_lowerhalf_s *dev);
|
|
#endif
|
|
static int virtio_snd_reserve(FAR struct audio_lowerhalf_s *dev);
|
|
static int virtio_snd_release(FAR struct audio_lowerhalf_s *dev);
|
|
#endif
|
|
static int virtio_snd_allocbuffer(FAR struct audio_lowerhalf_s *dev,
|
|
FAR struct audio_buf_desc_s *apb);
|
|
static int virtio_snd_freebuffer(FAR struct audio_lowerhalf_s *dev,
|
|
FAR struct audio_buf_desc_s *apb);
|
|
static int virtio_snd_enqueuebuffer(FAR struct audio_lowerhalf_s *dev,
|
|
FAR struct ap_buffer_s *apb);
|
|
static int virtio_snd_ioctl(FAR struct audio_lowerhalf_s *dev,
|
|
int cmd,
|
|
unsigned long arg);
|
|
static int virtio_snd_shutdown(FAR struct audio_lowerhalf_s *dev);
|
|
|
|
static int virtio_snd_probe(FAR struct virtio_device *vdev);
|
|
static void virtio_snd_remove(FAR struct virtio_device *vdev);
|
|
|
|
/****************************************************************************
|
|
* Private Data
|
|
****************************************************************************/
|
|
|
|
static const struct virtio_snd_rate_map_s g_rate_map[] =
|
|
{
|
|
[VIRTIO_SND_PCM_RATE_8000] =
|
|
{
|
|
AUDIO_SAMP_RATE_8K, 8000
|
|
},
|
|
[VIRTIO_SND_PCM_RATE_11025] =
|
|
{
|
|
AUDIO_SAMP_RATE_11K, 11025
|
|
},
|
|
[VIRTIO_SND_PCM_RATE_16000] =
|
|
{
|
|
AUDIO_SAMP_RATE_16K, 16000
|
|
},
|
|
[VIRTIO_SND_PCM_RATE_22050] =
|
|
{
|
|
AUDIO_SAMP_RATE_22K, 22050
|
|
},
|
|
[VIRTIO_SND_PCM_RATE_32000] =
|
|
{
|
|
AUDIO_SAMP_RATE_32K, 32000
|
|
},
|
|
[VIRTIO_SND_PCM_RATE_44100] =
|
|
{
|
|
AUDIO_SAMP_RATE_44K, 44100
|
|
},
|
|
[VIRTIO_SND_PCM_RATE_48000] =
|
|
{
|
|
AUDIO_SAMP_RATE_48K, 48000
|
|
},
|
|
[VIRTIO_SND_PCM_RATE_96000] =
|
|
{
|
|
AUDIO_SAMP_RATE_96K, 96000
|
|
},
|
|
[VIRTIO_SND_PCM_RATE_192000] =
|
|
{
|
|
AUDIO_SAMP_RATE_192K, 192000
|
|
}
|
|
};
|
|
|
|
static const struct virtio_snd_format_map_s g_format_map[] =
|
|
{
|
|
[VIRTIO_SND_PCM_FMT_S8] =
|
|
{
|
|
AUDIO_SUBFMT_PCM_S8, 8
|
|
},
|
|
[VIRTIO_SND_PCM_FMT_S16] =
|
|
{
|
|
AUDIO_SUBFMT_PCM_S16_LE, 16
|
|
},
|
|
[VIRTIO_SND_PCM_FMT_S32] =
|
|
{
|
|
AUDIO_SUBFMT_PCM_S32_LE, 32
|
|
}
|
|
};
|
|
|
|
static struct virtio_driver g_virtio_snd_driver =
|
|
{
|
|
LIST_INITIAL_VALUE(g_virtio_snd_driver.node), /* node */
|
|
VIRTIO_ID_SOUND, /* device id */
|
|
virtio_snd_probe, /* probe */
|
|
virtio_snd_remove, /* remove */
|
|
};
|
|
|
|
static const struct audio_ops_s g_virtio_snd_ops =
|
|
{
|
|
virtio_snd_getcaps, /* getcaps */
|
|
virtio_snd_configure, /* configure */
|
|
virtio_snd_shutdown, /* shutdown */
|
|
virtio_snd_start, /* start */
|
|
#ifndef CONFIG_AUDIO_EXCLUDE_STOP
|
|
virtio_snd_stop, /* stop */
|
|
#endif
|
|
#ifndef CONFIG_AUDIO_EXCLUDE_PAUSE_RESUME
|
|
virtio_snd_pause, /* pause */
|
|
virtio_snd_resume, /* resume */
|
|
#endif
|
|
virtio_snd_allocbuffer, /* allocbuffer */
|
|
virtio_snd_freebuffer, /* freebuffer */
|
|
virtio_snd_enqueuebuffer, /* enqueuebuffer */
|
|
NULL, /* cancelbuffer */
|
|
virtio_snd_ioctl, /* ioctl */
|
|
NULL, /* read */
|
|
NULL, /* write */
|
|
virtio_snd_reserve, /* reserve */
|
|
virtio_snd_release /* release */
|
|
};
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_get_period_bytes
|
|
****************************************************************************/
|
|
|
|
static unsigned int virtio_snd_get_period_bytes(unsigned int rate,
|
|
unsigned int ch,
|
|
unsigned int bps,
|
|
unsigned int period_time)
|
|
{
|
|
return rate * ch * (bps / 8) * period_time / 1000;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_get_support_rates
|
|
****************************************************************************/
|
|
|
|
static unsigned int
|
|
virtio_snd_get_support_rates(FAR const struct virtio_snd_pcm_info *info)
|
|
{
|
|
unsigned int rates = 0;
|
|
int i;
|
|
|
|
for (i = VIRTIO_SND_PCM_RATE_5512; i < VIRTIO_SND_PCM_RATE_384000; i++)
|
|
{
|
|
if (info->rates & (1 << i))
|
|
{
|
|
rates |= g_rate_map[i].nrate;
|
|
}
|
|
}
|
|
|
|
return rates;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_get_support_formats
|
|
****************************************************************************/
|
|
|
|
static void
|
|
virtio_snd_get_support_formats(FAR const struct virtio_snd_pcm_info *info,
|
|
FAR struct audio_caps_s *caps)
|
|
{
|
|
size_t subformats = 0;
|
|
size_t i;
|
|
|
|
for (i = 0; i < nitems(g_format_map); i++)
|
|
{
|
|
if (info->formats & (1 << i))
|
|
{
|
|
caps->ac_controls.b[subformats++] = g_format_map[i].nformat;
|
|
if (subformats >= nitems(caps->ac_controls.b))
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_pcm_notify_cb
|
|
****************************************************************************/
|
|
|
|
static void virtio_snd_pcm_notify_cb(FAR struct virtqueue *vq)
|
|
{
|
|
for (; ; )
|
|
{
|
|
FAR struct virtio_snd_buffer_s *buf;
|
|
buf = virtqueue_get_buffer(vq, NULL, NULL);
|
|
if (buf == NULL)
|
|
{
|
|
break;
|
|
}
|
|
|
|
#ifdef CONFIG_AUDIO_MULTI_SESSION
|
|
buf->dev->upper(buf->dev->priv, AUDIO_CALLBACK_DEQUEUE,
|
|
&buf->apb, OK, NULL);
|
|
#else
|
|
buf->dev->upper(buf->dev->priv, AUDIO_CALLBACK_DEQUEUE,
|
|
&buf->apb, OK);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_ctl_notify_cb
|
|
****************************************************************************/
|
|
|
|
static void virtio_snd_ctl_notify_cb(FAR struct virtqueue *vq)
|
|
{
|
|
FAR sem_t *ctl_sem;
|
|
|
|
ctl_sem = virtqueue_get_buffer(vq, NULL, NULL);
|
|
nxsem_post(ctl_sem);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_event_notify_cb
|
|
****************************************************************************/
|
|
|
|
static void virtio_snd_event_notify_cb(FAR struct virtqueue *vqueue)
|
|
{
|
|
vrtinfo("recvive jack/pcm event\n");
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_send_pcm
|
|
****************************************************************************/
|
|
|
|
static int virtio_snd_send_pcm(FAR struct virtio_snd_dev_s *sdev,
|
|
FAR struct virtio_snd_buffer_s *buf)
|
|
{
|
|
FAR struct virtio_snd_s *priv = sdev->priv;
|
|
FAR struct virtio_snd_pcm_info *info = &priv->info[sdev->index];
|
|
int idx = info->direction == VIRTIO_SND_D_INPUT ?
|
|
VIRTIO_SND_VQ_RX : VIRTIO_SND_VQ_TX;
|
|
FAR struct virtqueue *vq = priv->vdev->vrings_info[idx].vq;
|
|
struct virtqueue_buf vb[3];
|
|
|
|
vb[0].buf = &buf->xfer;
|
|
vb[0].len = sizeof(buf->xfer);
|
|
vb[1].buf = buf->apb.samp;
|
|
vb[1].len = sdev->period_bytes;
|
|
vb[2].buf = &buf->status;
|
|
vb[2].len = sizeof(buf->status);
|
|
|
|
if (idx == VIRTIO_SND_VQ_RX)
|
|
{
|
|
virtqueue_add_buffer(vq, vb, 1, 2, buf);
|
|
}
|
|
else
|
|
{
|
|
virtqueue_add_buffer(vq, vb, 2, 1, buf);
|
|
}
|
|
|
|
virtqueue_kick(vq);
|
|
|
|
return OK;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_send_ctl
|
|
****************************************************************************/
|
|
|
|
static int virtio_snd_send_ctl(FAR struct virtio_snd_s *priv,
|
|
FAR struct virtqueue_buf *vb,
|
|
int readable,
|
|
int writable)
|
|
{
|
|
FAR struct virtqueue *vq =
|
|
priv->vdev->vrings_info[VIRTIO_SND_VQ_CONTROL].vq;
|
|
sem_t ctl_sem;
|
|
int ret;
|
|
|
|
nxsem_init(&ctl_sem, 0, 0);
|
|
|
|
virtqueue_add_buffer(vq, vb, readable, writable, &ctl_sem);
|
|
virtqueue_kick(vq);
|
|
|
|
ret = nxsem_wait_uninterruptible(&ctl_sem);
|
|
nxsem_destroy(&ctl_sem);
|
|
if (ret < 0)
|
|
{
|
|
vrterr("nxsem wait error:%d\n", ret);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_query_info
|
|
****************************************************************************/
|
|
|
|
static int virtio_snd_query_info(FAR struct virtio_snd_s *priv,
|
|
int cmd,
|
|
size_t size,
|
|
size_t count,
|
|
FAR struct virtio_snd_pcm_info *info)
|
|
{
|
|
FAR struct virtio_snd_query_info *req;
|
|
FAR struct virtio_snd_hdr *resp;
|
|
struct virtqueue_buf vb[3];
|
|
int ret;
|
|
|
|
req = virtio_zalloc_buf(priv->vdev, sizeof(*req), 16);
|
|
if (req == NULL)
|
|
{
|
|
vrterr("virtio audio driver cmd request alloc failed\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
req->hdr.code = cmd;
|
|
req->count = count;
|
|
req->size = size;
|
|
|
|
resp = virtio_alloc_buf(priv->vdev, sizeof(*resp), 16);
|
|
if (resp == NULL)
|
|
{
|
|
vrterr("virtio audio driver cmd response alloc failed\n");
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
resp->code = VIRTIO_SND_S_IO_ERR;
|
|
|
|
vb[0].buf = req;
|
|
vb[0].len = sizeof(*req);
|
|
vb[1].buf = resp;
|
|
vb[1].len = sizeof(*resp);
|
|
vb[2].buf = info;
|
|
vb[2].len = count * size;
|
|
|
|
ret = virtio_snd_send_ctl(priv, vb, 1, 2);
|
|
if (ret < 0)
|
|
{
|
|
vrterr("send msg error:%d\n", ret);
|
|
goto out;
|
|
}
|
|
|
|
ret = resp->code == VIRTIO_SND_S_OK ? OK : -EIO;
|
|
vrtinfo("send cmd:0x%x and resp:0x%"PRIu32"\n", cmd, resp->code);
|
|
|
|
out:
|
|
virtio_free_buf(priv->vdev, req);
|
|
virtio_free_buf(priv->vdev, resp);
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_dev_set_params
|
|
****************************************************************************/
|
|
|
|
static int virtio_snd_set_params(FAR struct virtio_snd_dev_s *sdev,
|
|
unsigned int ch,
|
|
unsigned int rate,
|
|
unsigned int bps)
|
|
{
|
|
FAR struct virtio_snd_s *priv = sdev->priv;
|
|
FAR struct virtio_snd_pcm_set_params *req;
|
|
FAR struct virtio_snd_hdr *resp;
|
|
struct virtqueue_buf vb[2];
|
|
size_t i;
|
|
int ret;
|
|
|
|
req = virtio_zalloc_buf(priv->vdev, sizeof(*req), 16);
|
|
if (req == NULL)
|
|
{
|
|
vrterr("zalloc for request error\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
req->hdr.hdr.code = VIRTIO_SND_R_PCM_SET_PARAMS;
|
|
req->hdr.stream_id = sdev->index;
|
|
req->channels = ch;
|
|
|
|
req->rate = VIRTIO_SND_PCM_RATE_44100;
|
|
for (i = 0; i < nitems(g_rate_map); i++)
|
|
{
|
|
if (rate == g_rate_map[i].sps)
|
|
{
|
|
req->rate = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
req->format = VIRTIO_SND_PCM_FMT_S16;
|
|
for (i = 0; i < nitems(g_format_map); i++)
|
|
{
|
|
if (bps == g_format_map[i].bps)
|
|
{
|
|
req->format = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
req->period_bytes = sdev->period_bytes;
|
|
req->buffer_bytes = req->period_bytes *
|
|
CONFIG_DRIVERS_VIRTIO_SND_BUFFER_COUNT;
|
|
|
|
resp = virtio_alloc_buf(priv->vdev, sizeof(*resp), 16);
|
|
if (resp == NULL)
|
|
{
|
|
vrterr("zalloc for request error\n");
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
resp->code = VIRTIO_SND_S_IO_ERR;
|
|
|
|
vb[0].buf = req;
|
|
vb[0].len = sizeof(*req);
|
|
vb[1].buf = resp;
|
|
vb[1].len = sizeof(*resp);
|
|
|
|
ret = virtio_snd_send_ctl(priv, vb, 1, 1);
|
|
if (ret < 0)
|
|
{
|
|
vrterr("send msg error:%d\n", ret);
|
|
goto out;
|
|
}
|
|
|
|
ret = resp->code == VIRTIO_SND_S_OK ? OK : -EIO;
|
|
|
|
vrtinfo("send cmd:0x%x and resp:0x%"PRIu32"\n",
|
|
VIRTIO_SND_R_PCM_SET_PARAMS, resp->code);
|
|
|
|
out:
|
|
virtio_free_buf(priv->vdev, req);
|
|
virtio_free_buf(priv->vdev, resp);
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_send_cmd
|
|
****************************************************************************/
|
|
|
|
static int virtio_snd_send_cmd(FAR struct virtio_snd_dev_s *sdev,
|
|
int cmd)
|
|
{
|
|
FAR struct virtio_snd_s *priv = sdev->priv;
|
|
FAR struct virtio_device *vdev = priv->vdev;
|
|
FAR struct virtio_snd_pcm_hdr *req;
|
|
FAR struct virtio_snd_hdr *resp;
|
|
struct virtqueue_buf vb[2];
|
|
int ret;
|
|
|
|
req = virtio_alloc_buf(vdev, sizeof(*req), 16);
|
|
if (req == NULL)
|
|
{
|
|
vrterr("zalloc for request error\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
req->hdr.code = cmd;
|
|
req->stream_id = sdev->index;
|
|
|
|
resp = virtio_alloc_buf(vdev, sizeof(*resp), 16);
|
|
if (resp == NULL)
|
|
{
|
|
vrterr("zalloc for request error\n");
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
resp->code = VIRTIO_SND_S_IO_ERR;
|
|
|
|
vb[0].buf = req;
|
|
vb[0].len = sizeof(*req);
|
|
vb[1].buf = resp;
|
|
vb[1].len = sizeof(*resp);
|
|
|
|
ret = virtio_snd_send_ctl(priv, vb, 1, 1);
|
|
if (ret < 0)
|
|
{
|
|
vrterr("send msg error:%d\n", ret);
|
|
goto out;
|
|
}
|
|
|
|
ret = resp->code == VIRTIO_SND_S_OK ? OK : -EIO;
|
|
if (ret < 0)
|
|
{
|
|
vrterr("check response error:%d\n", ret);
|
|
}
|
|
|
|
vrtinfo("send cmd:0x%x and resp:0x%"PRIu32"\n", cmd, resp->code);
|
|
|
|
out:
|
|
virtio_free_buf(vdev, req);
|
|
virtio_free_buf(vdev, resp);
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_getcaps
|
|
****************************************************************************/
|
|
|
|
static int virtio_snd_getcaps(FAR struct audio_lowerhalf_s *dev,
|
|
int type,
|
|
FAR struct audio_caps_s *caps)
|
|
{
|
|
FAR struct virtio_snd_dev_s *sdev = (FAR struct virtio_snd_dev_s *)dev;
|
|
FAR struct virtio_snd_s *priv = sdev->priv;
|
|
FAR struct virtio_snd_pcm_info *info = &priv->info[sdev->index];
|
|
|
|
DEBUGASSERT(caps->ac_len >= sizeof(struct audio_caps_s));
|
|
|
|
caps->ac_format.hw = 0;
|
|
caps->ac_controls.w = 0;
|
|
|
|
switch (caps->ac_type)
|
|
{
|
|
case AUDIO_TYPE_QUERY:
|
|
switch (caps->ac_subtype)
|
|
{
|
|
case AUDIO_TYPE_QUERY:
|
|
caps->ac_controls.b[0] =
|
|
info->direction == VIRTIO_SND_D_INPUT ?
|
|
AUDIO_TYPE_INPUT : AUDIO_TYPE_OUTPUT;
|
|
caps->ac_format.hw = 1 << (AUDIO_FMT_PCM - 1);
|
|
break;
|
|
|
|
case AUDIO_FMT_PCM:
|
|
virtio_snd_get_support_formats(info, caps);
|
|
break;
|
|
|
|
default:
|
|
caps->ac_controls.b[0] = AUDIO_SUBFMT_END;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case AUDIO_TYPE_OUTPUT:
|
|
case AUDIO_TYPE_INPUT:
|
|
{
|
|
caps->ac_channels = (info->channels_min << 4) |
|
|
(info->channels_max & 0x0f);
|
|
switch (caps->ac_subtype)
|
|
{
|
|
case AUDIO_TYPE_QUERY:
|
|
caps->ac_controls.b[0] = virtio_snd_get_support_rates(info);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
caps->ac_subtype = 0;
|
|
caps->ac_channels = 0;
|
|
break;
|
|
}
|
|
|
|
return caps->ac_len;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_configure
|
|
*
|
|
* Description:
|
|
* Configure the audio device for the specified mode of operation.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_AUDIO_MULTI_SESSION
|
|
static int virtio_snd_configure(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void *session,
|
|
FAR const struct audio_caps_s *caps)
|
|
#else
|
|
static int virtio_snd_configure(FAR struct audio_lowerhalf_s *dev,
|
|
FAR const struct audio_caps_s *caps)
|
|
#endif
|
|
{
|
|
FAR struct virtio_snd_dev_s *sdev = (FAR struct virtio_snd_dev_s *)dev;
|
|
int ret = -ENOTTY;
|
|
uint32_t rate;
|
|
uint8_t bps;
|
|
uint8_t ch;
|
|
|
|
switch (caps->ac_type)
|
|
{
|
|
case AUDIO_TYPE_OUTPUT:
|
|
case AUDIO_TYPE_INPUT:
|
|
vrtinfo("Number of channels: %"PRIu8"\n", caps->ac_channels);
|
|
vrtinfo("Sample rate: %"PRIu16"\n", caps->ac_controls.hw[0]);
|
|
vrtinfo("Sample width: %"PRIu8"\n", caps->ac_controls.b[2]);
|
|
vrtinfo("channel map: 0x%x\n", caps->ac_chmap);
|
|
rate = caps->ac_controls.hw[0] | (caps->ac_controls.b[3] << 16);
|
|
bps = caps->ac_controls.b[2];
|
|
ch = caps->ac_channels;
|
|
sdev->period_bytes =
|
|
virtio_snd_get_period_bytes(rate, ch, bps,
|
|
CONFIG_DRIVERS_VIRTIO_SOUND_PERIOD_TIME);
|
|
vrtinfo("period_bytes:%"PRIu32"\n", sdev->period_bytes);
|
|
ret = virtio_snd_set_params(sdev, ch, rate, bps);
|
|
if (ret < 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
ret = virtio_snd_send_cmd(sdev, VIRTIO_SND_R_PCM_PREPARE);
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_start
|
|
*
|
|
* Description:
|
|
* Start the configured operation (audio streaming, volume enabled, etc.).
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_AUDIO_MULTI_SESSION
|
|
static int virtio_snd_start(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void *session)
|
|
#else
|
|
static int virtio_snd_start(FAR struct audio_lowerhalf_s *dev)
|
|
#endif
|
|
{
|
|
FAR struct virtio_snd_dev_s *sdev = (FAR struct virtio_snd_dev_s *)dev;
|
|
int ret = OK;
|
|
|
|
if (!sdev->running)
|
|
{
|
|
ret = virtio_snd_send_cmd(sdev, VIRTIO_SND_R_PCM_START);
|
|
if (ret < 0)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
sdev->running = true;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_stop
|
|
*
|
|
* Description: Stop the configured operation (audio streaming, volume
|
|
* disabled, etc.).
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifndef CONFIG_AUDIO_EXCLUDE_STOP
|
|
#ifdef CONFIG_AUDIO_MULTI_SESSION
|
|
static int virtio_snd_stop(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void *session)
|
|
#else
|
|
static int virtio_snd_stop(FAR struct audio_lowerhalf_s *dev)
|
|
#endif
|
|
{
|
|
FAR struct virtio_snd_dev_s *sdev = (FAR struct virtio_snd_dev_s *)dev;
|
|
int ret = OK;
|
|
|
|
if (sdev->running)
|
|
{
|
|
ret = virtio_snd_send_cmd(sdev, VIRTIO_SND_R_PCM_STOP);
|
|
if (ret < 0)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
sdev->running = false;
|
|
}
|
|
|
|
ret = virtio_snd_send_cmd(sdev, VIRTIO_SND_R_PCM_RELEASE);
|
|
if (ret < 0)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_AUDIO_MULTI_SESSION
|
|
dev->upper(dev->priv, AUDIO_CALLBACK_COMPLETE, NULL, OK, NULL);
|
|
#else
|
|
dev->upper(dev->priv, AUDIO_CALLBACK_COMPLETE, NULL, OK);
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_pause
|
|
*
|
|
* Description: Pauses the playback.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifndef CONFIG_AUDIO_EXCLUDE_PAUSE_RESUME
|
|
#ifdef CONFIG_AUDIO_MULTI_SESSION
|
|
static int virtio_snd_pause(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void *session)
|
|
#else
|
|
static int virtio_snd_pause(FAR struct audio_lowerhalf_s *dev)
|
|
#endif
|
|
{
|
|
FAR struct virtio_snd_dev_s *sdev = (FAR struct virtio_snd_dev_s *)dev;
|
|
int ret = OK;
|
|
|
|
if (sdev->running)
|
|
{
|
|
ret = virtio_snd_send_cmd(sdev, VIRTIO_SND_R_PCM_STOP);
|
|
if (ret < 0)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
sdev->running = false;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_resume
|
|
*
|
|
* Description: Resumes the playback.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifndef CONFIG_AUDIO_EXCLUDE_PAUSE_RESUME
|
|
#ifdef CONFIG_AUDIO_MULTI_SESSION
|
|
static int virtio_snd_resume(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void *session)
|
|
#else
|
|
static int virtio_snd_resume(FAR struct audio_lowerhalf_s *dev)
|
|
#endif
|
|
{
|
|
FAR struct virtio_snd_dev_s *sdev = (FAR struct virtio_snd_dev_s *)dev;
|
|
int ret = OK;
|
|
|
|
if (!sdev->running)
|
|
{
|
|
ret = virtio_snd_send_cmd(sdev, VIRTIO_SND_R_PCM_START);
|
|
if (ret < 0)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
sdev->running = true;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
static int virtio_snd_allocbuffer(FAR struct audio_lowerhalf_s *dev,
|
|
FAR struct audio_buf_desc_s *desc)
|
|
{
|
|
FAR struct virtio_snd_dev_s *sdev = (FAR struct virtio_snd_dev_s *)dev;
|
|
FAR struct virtio_snd_s *priv = sdev->priv;
|
|
FAR struct virtio_snd_buffer_s *buf;
|
|
|
|
DEBUGASSERT(desc->u.pbuffer != NULL);
|
|
|
|
buf = virtio_zalloc_buf(priv->vdev, sizeof(*buf) + desc->numbytes, 16);
|
|
if (buf == NULL)
|
|
{
|
|
vrterr("failed to allocate apb buffer\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
*desc->u.pbuffer = &buf->apb;
|
|
|
|
buf->apb.crefs = 1;
|
|
buf->apb.nmaxbytes = desc->numbytes;
|
|
buf->apb.samp = (FAR uint8_t *)(buf + 1);
|
|
#ifdef CONFIG_AUDIO_MULTI_SESSION
|
|
buf->apb.session = desc->session;
|
|
#endif
|
|
buf->xfer.stream_id = sdev->index;
|
|
buf->status.status = VIRTIO_SND_S_IO_ERR;
|
|
buf->dev = dev;
|
|
nxmutex_init(&buf->apb.lock);
|
|
|
|
return sizeof(struct audio_buf_desc_s);
|
|
}
|
|
|
|
static int virtio_snd_freebuffer(FAR struct audio_lowerhalf_s *dev,
|
|
FAR struct audio_buf_desc_s *desc)
|
|
{
|
|
FAR struct virtio_snd_dev_s *sdev = (FAR struct virtio_snd_dev_s *)dev;
|
|
FAR struct virtio_snd_s *priv = sdev->priv;
|
|
FAR struct virtio_device *vdev = priv->vdev;
|
|
FAR struct ap_buffer_s *apb = desc->u.buffer;
|
|
int refcount;
|
|
|
|
nxmutex_lock(&apb->lock);
|
|
refcount = apb->crefs--;
|
|
nxmutex_unlock(&apb->lock);
|
|
if (refcount <= 1)
|
|
{
|
|
nxmutex_destroy(&apb->lock);
|
|
virtio_free_buf(vdev, apb);
|
|
}
|
|
|
|
return sizeof(struct audio_buf_desc_s);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_enqueuebuffer
|
|
*
|
|
* Description: Enqueue an Audio Pipeline Buffer for playback/ processing.
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int virtio_snd_enqueuebuffer(FAR struct audio_lowerhalf_s *dev,
|
|
FAR struct ap_buffer_s *apb)
|
|
{
|
|
FAR struct virtio_snd_dev_s *sdev = (FAR struct virtio_snd_dev_s *)dev;
|
|
FAR struct virtio_snd_buffer_s *buf =
|
|
(FAR struct virtio_snd_buffer_s *)apb;
|
|
|
|
return virtio_snd_send_pcm(sdev, buf);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_ioctl
|
|
*
|
|
* Description: Perform a device ioctl
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int virtio_snd_ioctl(FAR struct audio_lowerhalf_s *dev,
|
|
int cmd,
|
|
unsigned long arg)
|
|
{
|
|
FAR struct virtio_snd_dev_s *sdev = (FAR struct virtio_snd_dev_s *)dev;
|
|
FAR struct ap_buffer_info_s *bufinfo;
|
|
|
|
switch (cmd)
|
|
{
|
|
case AUDIOIOC_GETBUFFERINFO:
|
|
bufinfo = (FAR struct ap_buffer_info_s *)arg;
|
|
bufinfo->nbuffers = CONFIG_DRIVERS_VIRTIO_SND_BUFFER_COUNT;
|
|
bufinfo->buffer_size = sdev->period_bytes;
|
|
break;
|
|
|
|
default:
|
|
return -ENOTTY;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_shutdown
|
|
*
|
|
* Description:
|
|
* Shutdown the driver and put it in the lowest power state possible.
|
|
*
|
|
****************************************************************************/
|
|
|
|
static int virtio_snd_shutdown(FAR struct audio_lowerhalf_s *dev)
|
|
{
|
|
vrtinfo("Return OK\n");
|
|
return OK;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_reserve
|
|
*
|
|
* Description: Reserves a session (the only one we have).
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_AUDIO_MULTI_SESSION
|
|
static int virtio_snd_reserve(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void **session)
|
|
#else
|
|
static int virtio_snd_reserve(FAR struct audio_lowerhalf_s *dev)
|
|
#endif
|
|
{
|
|
vrtinfo("Return OK\n");
|
|
return OK;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_release
|
|
*
|
|
* Description: Releases the session (the only one we have).
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_AUDIO_MULTI_SESSION
|
|
static int virtio_snd_release(FAR struct audio_lowerhalf_s *dev,
|
|
FAR void *session)
|
|
#else
|
|
static int virtio_snd_release(FAR struct audio_lowerhalf_s *dev)
|
|
#endif
|
|
{
|
|
vrtinfo("Return OK\n");
|
|
return OK;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_init
|
|
****************************************************************************/
|
|
|
|
static int virtio_snd_init(FAR struct virtio_snd_s *priv)
|
|
{
|
|
FAR const char *vqnames[VIRTIO_SND_VQ_MAX];
|
|
vq_callback callbacks[VIRTIO_SND_VQ_MAX];
|
|
int ret;
|
|
int i;
|
|
|
|
vqnames[VIRTIO_SND_VQ_CONTROL] = "virtsnd-ctl";
|
|
vqnames[VIRTIO_SND_VQ_EVENT] = "virtsnd-event";
|
|
vqnames[VIRTIO_SND_VQ_TX] = "virtsnd-tx";
|
|
vqnames[VIRTIO_SND_VQ_RX] = "virtsnd-rx";
|
|
|
|
callbacks[VIRTIO_SND_VQ_CONTROL] = virtio_snd_ctl_notify_cb;
|
|
callbacks[VIRTIO_SND_VQ_EVENT] = virtio_snd_event_notify_cb;
|
|
callbacks[VIRTIO_SND_VQ_TX] = virtio_snd_pcm_notify_cb;
|
|
callbacks[VIRTIO_SND_VQ_RX] = virtio_snd_pcm_notify_cb;
|
|
|
|
ret = virtio_create_virtqueues(priv->vdev, 0,
|
|
VIRTIO_SND_VQ_MAX, vqnames, callbacks);
|
|
if (ret < 0)
|
|
{
|
|
vrterr("virtio_device_create_virtqueue failed, ret=%d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
for (i = 0; i < VIRTIO_SND_VQ_MAX; i++)
|
|
{
|
|
virtqueue_enable_cb(priv->vdev->vrings_info[i].vq);
|
|
}
|
|
|
|
virtio_set_status(priv->vdev, VIRTIO_CONFIG_STATUS_DRIVER_OK);
|
|
|
|
virtio_read_config(priv->vdev, 0, &priv->config,
|
|
sizeof(struct virtio_snd_config));
|
|
vrtinfo("jacks:%"PRIu32" streams:%"PRIu32" chmap:%"PRIu32"\n",
|
|
priv->config.jacks, priv->config.streams, priv->config.chmaps);
|
|
|
|
priv->info = virtio_alloc_buf(priv->vdev,
|
|
priv->config.streams *
|
|
sizeof(struct virtio_snd_pcm_info),
|
|
16);
|
|
if (priv->info == NULL)
|
|
{
|
|
vrterr("virtio audio driver query pcm info alloc failed\n");
|
|
ret = -ENOMEM;
|
|
goto err_with_vq;
|
|
}
|
|
|
|
/* Query pcm info */
|
|
|
|
ret = virtio_snd_query_info(priv, VIRTIO_SND_R_PCM_INFO,
|
|
sizeof(struct virtio_snd_pcm_info),
|
|
priv->config.streams,
|
|
priv->info);
|
|
if (ret < 0)
|
|
{
|
|
vrterr("virtio snd query pcm info failed,ret:%d\n", ret);
|
|
goto err_with_info;
|
|
}
|
|
|
|
return ret;
|
|
|
|
err_with_info:
|
|
virtio_free_buf(priv->vdev, priv->info);
|
|
err_with_vq:
|
|
virtio_delete_virtqueues(priv->vdev);
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
virtio_snd_register_audio_driver(FAR struct virtio_snd_s *priv)
|
|
{
|
|
char devname[32];
|
|
int tx_minor = 0;
|
|
int rx_minor = 0;
|
|
int ret = -ENODEV;
|
|
uint32_t i;
|
|
|
|
priv->dev = kmm_zalloc(priv->config.streams *
|
|
sizeof(struct virtio_snd_dev_s));
|
|
if (priv->dev == NULL)
|
|
{
|
|
vrterr("zalloc for virtio audio device failed\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
for (i = 0; i < priv->config.streams; i++)
|
|
{
|
|
switch (priv->info[i].direction)
|
|
{
|
|
case VIRTIO_SND_D_OUTPUT:
|
|
snprintf(devname, sizeof(devname), "pcm%dp", tx_minor++);
|
|
break;
|
|
|
|
case VIRTIO_SND_D_INPUT:
|
|
snprintf(devname, sizeof(devname), "pcm%dc", rx_minor++);
|
|
break;
|
|
}
|
|
|
|
priv->dev[i].index = i;
|
|
priv->dev[i].running = false;
|
|
priv->dev[i].priv = priv;
|
|
priv->dev[i].dev.ops = &g_virtio_snd_ops;
|
|
ret = audio_register(devname, &priv->dev[i].dev);
|
|
if (ret < 0)
|
|
{
|
|
vrterr("failed to register /dev/%s device: %d\n",
|
|
devname, ret);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == 0)
|
|
{
|
|
kmm_free(priv->dev);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_probe
|
|
****************************************************************************/
|
|
|
|
static int virtio_snd_probe(FAR struct virtio_device *vdev)
|
|
{
|
|
FAR struct virtio_snd_s *priv;
|
|
int ret;
|
|
|
|
priv = kmm_zalloc(sizeof(*priv));
|
|
if (priv == NULL)
|
|
{
|
|
vrterr("virtio net driver priv alloc failed\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
priv->vdev = vdev;
|
|
vdev->priv = priv;
|
|
|
|
ret = virtio_snd_init(priv);
|
|
if (ret < 0)
|
|
{
|
|
goto err_with_virtsnd;
|
|
}
|
|
|
|
ret = virtio_snd_register_audio_driver(priv);
|
|
if (ret < 0)
|
|
{
|
|
goto err_with_vq;
|
|
}
|
|
|
|
return ret;
|
|
|
|
err_with_vq:
|
|
virtio_reset_device(vdev);
|
|
virtio_delete_virtqueues(vdev);
|
|
virtio_free_buf(vdev, priv->info);
|
|
err_with_virtsnd:
|
|
kmm_free(priv);
|
|
return ret;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_snd_remove
|
|
****************************************************************************/
|
|
|
|
static void virtio_snd_remove(FAR struct virtio_device *vdev)
|
|
{
|
|
FAR struct virtio_snd_s *priv = vdev->priv;
|
|
|
|
virtio_reset_device(vdev);
|
|
virtio_delete_virtqueues(vdev);
|
|
virtio_free_buf(vdev, priv->info);
|
|
kmm_free(priv->dev);
|
|
kmm_free(priv);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: virtio_register_snd_driver
|
|
****************************************************************************/
|
|
|
|
int virtio_register_snd_driver(void)
|
|
{
|
|
return virtio_register_driver(&g_virtio_snd_driver);
|
|
}
|