forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
519 lines
13 KiB
519 lines
13 KiB
// SPDX-License-Identifier: GPL-2.0 OR MIT |
|
|
|
/* |
|
* Xen para-virtual sound device |
|
* |
|
* Copyright (C) 2016-2018 EPAM Systems Inc. |
|
* |
|
* Author: Oleksandr Andrushchenko <[email protected]> |
|
*/ |
|
|
|
#include <xen/xenbus.h> |
|
|
|
#include <xen/interface/io/sndif.h> |
|
|
|
#include "xen_snd_front.h" |
|
#include "xen_snd_front_cfg.h" |
|
|
|
/* Maximum number of supported streams. */ |
|
#define VSND_MAX_STREAM 8 |
|
|
|
struct cfg_hw_sample_rate { |
|
const char *name; |
|
unsigned int mask; |
|
unsigned int value; |
|
}; |
|
|
|
static const struct cfg_hw_sample_rate CFG_HW_SUPPORTED_RATES[] = { |
|
{ .name = "5512", .mask = SNDRV_PCM_RATE_5512, .value = 5512 }, |
|
{ .name = "8000", .mask = SNDRV_PCM_RATE_8000, .value = 8000 }, |
|
{ .name = "11025", .mask = SNDRV_PCM_RATE_11025, .value = 11025 }, |
|
{ .name = "16000", .mask = SNDRV_PCM_RATE_16000, .value = 16000 }, |
|
{ .name = "22050", .mask = SNDRV_PCM_RATE_22050, .value = 22050 }, |
|
{ .name = "32000", .mask = SNDRV_PCM_RATE_32000, .value = 32000 }, |
|
{ .name = "44100", .mask = SNDRV_PCM_RATE_44100, .value = 44100 }, |
|
{ .name = "48000", .mask = SNDRV_PCM_RATE_48000, .value = 48000 }, |
|
{ .name = "64000", .mask = SNDRV_PCM_RATE_64000, .value = 64000 }, |
|
{ .name = "96000", .mask = SNDRV_PCM_RATE_96000, .value = 96000 }, |
|
{ .name = "176400", .mask = SNDRV_PCM_RATE_176400, .value = 176400 }, |
|
{ .name = "192000", .mask = SNDRV_PCM_RATE_192000, .value = 192000 }, |
|
}; |
|
|
|
struct cfg_hw_sample_format { |
|
const char *name; |
|
u64 mask; |
|
}; |
|
|
|
static const struct cfg_hw_sample_format CFG_HW_SUPPORTED_FORMATS[] = { |
|
{ |
|
.name = XENSND_PCM_FORMAT_U8_STR, |
|
.mask = SNDRV_PCM_FMTBIT_U8 |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_S8_STR, |
|
.mask = SNDRV_PCM_FMTBIT_S8 |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_U16_LE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_U16_LE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_U16_BE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_U16_BE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_S16_LE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_S16_LE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_S16_BE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_S16_BE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_U24_LE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_U24_LE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_U24_BE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_U24_BE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_S24_LE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_S24_LE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_S24_BE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_S24_BE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_U32_LE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_U32_LE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_U32_BE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_U32_BE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_S32_LE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_S32_LE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_S32_BE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_S32_BE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_A_LAW_STR, |
|
.mask = SNDRV_PCM_FMTBIT_A_LAW |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_MU_LAW_STR, |
|
.mask = SNDRV_PCM_FMTBIT_MU_LAW |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_F32_LE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_FLOAT_LE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_F32_BE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_FLOAT_BE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_F64_LE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_FLOAT64_LE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_F64_BE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_FLOAT64_BE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_IEC958_SUBFRAME_LE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_IEC958_SUBFRAME_BE_STR, |
|
.mask = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_IMA_ADPCM_STR, |
|
.mask = SNDRV_PCM_FMTBIT_IMA_ADPCM |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_MPEG_STR, |
|
.mask = SNDRV_PCM_FMTBIT_MPEG |
|
}, |
|
{ |
|
.name = XENSND_PCM_FORMAT_GSM_STR, |
|
.mask = SNDRV_PCM_FMTBIT_GSM |
|
}, |
|
}; |
|
|
|
static void cfg_hw_rates(char *list, unsigned int len, |
|
const char *path, struct snd_pcm_hardware *pcm_hw) |
|
{ |
|
char *cur_rate; |
|
unsigned int cur_mask; |
|
unsigned int cur_value; |
|
unsigned int rates; |
|
unsigned int rate_min; |
|
unsigned int rate_max; |
|
int i; |
|
|
|
rates = 0; |
|
rate_min = -1; |
|
rate_max = 0; |
|
while ((cur_rate = strsep(&list, XENSND_LIST_SEPARATOR))) { |
|
for (i = 0; i < ARRAY_SIZE(CFG_HW_SUPPORTED_RATES); i++) |
|
if (!strncasecmp(cur_rate, |
|
CFG_HW_SUPPORTED_RATES[i].name, |
|
XENSND_SAMPLE_RATE_MAX_LEN)) { |
|
cur_mask = CFG_HW_SUPPORTED_RATES[i].mask; |
|
cur_value = CFG_HW_SUPPORTED_RATES[i].value; |
|
rates |= cur_mask; |
|
if (rate_min > cur_value) |
|
rate_min = cur_value; |
|
if (rate_max < cur_value) |
|
rate_max = cur_value; |
|
} |
|
} |
|
|
|
if (rates) { |
|
pcm_hw->rates = rates; |
|
pcm_hw->rate_min = rate_min; |
|
pcm_hw->rate_max = rate_max; |
|
} |
|
} |
|
|
|
static void cfg_formats(char *list, unsigned int len, |
|
const char *path, struct snd_pcm_hardware *pcm_hw) |
|
{ |
|
u64 formats; |
|
char *cur_format; |
|
int i; |
|
|
|
formats = 0; |
|
while ((cur_format = strsep(&list, XENSND_LIST_SEPARATOR))) { |
|
for (i = 0; i < ARRAY_SIZE(CFG_HW_SUPPORTED_FORMATS); i++) |
|
if (!strncasecmp(cur_format, |
|
CFG_HW_SUPPORTED_FORMATS[i].name, |
|
XENSND_SAMPLE_FORMAT_MAX_LEN)) |
|
formats |= CFG_HW_SUPPORTED_FORMATS[i].mask; |
|
} |
|
|
|
if (formats) |
|
pcm_hw->formats = formats; |
|
} |
|
|
|
#define MAX_BUFFER_SIZE (64 * 1024) |
|
#define MIN_PERIOD_SIZE 64 |
|
#define MAX_PERIOD_SIZE MAX_BUFFER_SIZE |
|
#define USE_FORMATS (SNDRV_PCM_FMTBIT_U8 | \ |
|
SNDRV_PCM_FMTBIT_S16_LE) |
|
#define USE_RATE (SNDRV_PCM_RATE_CONTINUOUS | \ |
|
SNDRV_PCM_RATE_8000_48000) |
|
#define USE_RATE_MIN 5512 |
|
#define USE_RATE_MAX 48000 |
|
#define USE_CHANNELS_MIN 1 |
|
#define USE_CHANNELS_MAX 2 |
|
#define USE_PERIODS_MIN 2 |
|
#define USE_PERIODS_MAX (MAX_BUFFER_SIZE / MIN_PERIOD_SIZE) |
|
|
|
static const struct snd_pcm_hardware SND_DRV_PCM_HW_DEFAULT = { |
|
.info = (SNDRV_PCM_INFO_MMAP | |
|
SNDRV_PCM_INFO_INTERLEAVED | |
|
SNDRV_PCM_INFO_RESUME | |
|
SNDRV_PCM_INFO_MMAP_VALID), |
|
.formats = USE_FORMATS, |
|
.rates = USE_RATE, |
|
.rate_min = USE_RATE_MIN, |
|
.rate_max = USE_RATE_MAX, |
|
.channels_min = USE_CHANNELS_MIN, |
|
.channels_max = USE_CHANNELS_MAX, |
|
.buffer_bytes_max = MAX_BUFFER_SIZE, |
|
.period_bytes_min = MIN_PERIOD_SIZE, |
|
.period_bytes_max = MAX_PERIOD_SIZE, |
|
.periods_min = USE_PERIODS_MIN, |
|
.periods_max = USE_PERIODS_MAX, |
|
.fifo_size = 0, |
|
}; |
|
|
|
static void cfg_read_pcm_hw(const char *path, |
|
struct snd_pcm_hardware *parent_pcm_hw, |
|
struct snd_pcm_hardware *pcm_hw) |
|
{ |
|
char *list; |
|
int val; |
|
size_t buf_sz; |
|
unsigned int len; |
|
|
|
/* Inherit parent's PCM HW and read overrides from XenStore. */ |
|
if (parent_pcm_hw) |
|
*pcm_hw = *parent_pcm_hw; |
|
else |
|
*pcm_hw = SND_DRV_PCM_HW_DEFAULT; |
|
|
|
val = xenbus_read_unsigned(path, XENSND_FIELD_CHANNELS_MIN, 0); |
|
if (val) |
|
pcm_hw->channels_min = val; |
|
|
|
val = xenbus_read_unsigned(path, XENSND_FIELD_CHANNELS_MAX, 0); |
|
if (val) |
|
pcm_hw->channels_max = val; |
|
|
|
list = xenbus_read(XBT_NIL, path, XENSND_FIELD_SAMPLE_RATES, &len); |
|
if (!IS_ERR(list)) { |
|
cfg_hw_rates(list, len, path, pcm_hw); |
|
kfree(list); |
|
} |
|
|
|
list = xenbus_read(XBT_NIL, path, XENSND_FIELD_SAMPLE_FORMATS, &len); |
|
if (!IS_ERR(list)) { |
|
cfg_formats(list, len, path, pcm_hw); |
|
kfree(list); |
|
} |
|
|
|
buf_sz = xenbus_read_unsigned(path, XENSND_FIELD_BUFFER_SIZE, 0); |
|
if (buf_sz) |
|
pcm_hw->buffer_bytes_max = buf_sz; |
|
|
|
/* Update configuration to match new values. */ |
|
if (pcm_hw->channels_min > pcm_hw->channels_max) |
|
pcm_hw->channels_min = pcm_hw->channels_max; |
|
|
|
if (pcm_hw->rate_min > pcm_hw->rate_max) |
|
pcm_hw->rate_min = pcm_hw->rate_max; |
|
|
|
pcm_hw->period_bytes_max = pcm_hw->buffer_bytes_max; |
|
|
|
pcm_hw->periods_max = pcm_hw->period_bytes_max / |
|
pcm_hw->period_bytes_min; |
|
} |
|
|
|
static int cfg_get_stream_type(const char *path, int index, |
|
int *num_pb, int *num_cap) |
|
{ |
|
char *str = NULL; |
|
char *stream_path; |
|
int ret; |
|
|
|
*num_pb = 0; |
|
*num_cap = 0; |
|
stream_path = kasprintf(GFP_KERNEL, "%s/%d", path, index); |
|
if (!stream_path) { |
|
ret = -ENOMEM; |
|
goto fail; |
|
} |
|
|
|
str = xenbus_read(XBT_NIL, stream_path, XENSND_FIELD_TYPE, NULL); |
|
if (IS_ERR(str)) { |
|
ret = PTR_ERR(str); |
|
str = NULL; |
|
goto fail; |
|
} |
|
|
|
if (!strncasecmp(str, XENSND_STREAM_TYPE_PLAYBACK, |
|
sizeof(XENSND_STREAM_TYPE_PLAYBACK))) { |
|
(*num_pb)++; |
|
} else if (!strncasecmp(str, XENSND_STREAM_TYPE_CAPTURE, |
|
sizeof(XENSND_STREAM_TYPE_CAPTURE))) { |
|
(*num_cap)++; |
|
} else { |
|
ret = -EINVAL; |
|
goto fail; |
|
} |
|
ret = 0; |
|
|
|
fail: |
|
kfree(stream_path); |
|
kfree(str); |
|
return ret; |
|
} |
|
|
|
static int cfg_stream(struct xen_snd_front_info *front_info, |
|
struct xen_front_cfg_pcm_instance *pcm_instance, |
|
const char *path, int index, int *cur_pb, int *cur_cap, |
|
int *stream_cnt) |
|
{ |
|
char *str = NULL; |
|
char *stream_path; |
|
struct xen_front_cfg_stream *stream; |
|
int ret; |
|
|
|
stream_path = devm_kasprintf(&front_info->xb_dev->dev, |
|
GFP_KERNEL, "%s/%d", path, index); |
|
if (!stream_path) { |
|
ret = -ENOMEM; |
|
goto fail; |
|
} |
|
|
|
str = xenbus_read(XBT_NIL, stream_path, XENSND_FIELD_TYPE, NULL); |
|
if (IS_ERR(str)) { |
|
ret = PTR_ERR(str); |
|
str = NULL; |
|
goto fail; |
|
} |
|
|
|
if (!strncasecmp(str, XENSND_STREAM_TYPE_PLAYBACK, |
|
sizeof(XENSND_STREAM_TYPE_PLAYBACK))) { |
|
stream = &pcm_instance->streams_pb[(*cur_pb)++]; |
|
} else if (!strncasecmp(str, XENSND_STREAM_TYPE_CAPTURE, |
|
sizeof(XENSND_STREAM_TYPE_CAPTURE))) { |
|
stream = &pcm_instance->streams_cap[(*cur_cap)++]; |
|
} else { |
|
ret = -EINVAL; |
|
goto fail; |
|
} |
|
|
|
/* Get next stream index. */ |
|
stream->index = (*stream_cnt)++; |
|
stream->xenstore_path = stream_path; |
|
/* |
|
* Check XenStore if PCM HW configuration exists for this stream |
|
* and update if so, e.g. we inherit all values from device's PCM HW, |
|
* but can still override some of the values for the stream. |
|
*/ |
|
cfg_read_pcm_hw(stream->xenstore_path, |
|
&pcm_instance->pcm_hw, &stream->pcm_hw); |
|
ret = 0; |
|
|
|
fail: |
|
kfree(str); |
|
return ret; |
|
} |
|
|
|
static int cfg_device(struct xen_snd_front_info *front_info, |
|
struct xen_front_cfg_pcm_instance *pcm_instance, |
|
struct snd_pcm_hardware *parent_pcm_hw, |
|
const char *path, int node_index, int *stream_cnt) |
|
{ |
|
char *str; |
|
char *device_path; |
|
int ret, i, num_streams; |
|
int num_pb, num_cap; |
|
int cur_pb, cur_cap; |
|
char node[3]; |
|
|
|
device_path = kasprintf(GFP_KERNEL, "%s/%d", path, node_index); |
|
if (!device_path) |
|
return -ENOMEM; |
|
|
|
str = xenbus_read(XBT_NIL, device_path, XENSND_FIELD_DEVICE_NAME, NULL); |
|
if (!IS_ERR(str)) { |
|
strscpy(pcm_instance->name, str, sizeof(pcm_instance->name)); |
|
kfree(str); |
|
} |
|
|
|
pcm_instance->device_id = node_index; |
|
|
|
/* |
|
* Check XenStore if PCM HW configuration exists for this device |
|
* and update if so, e.g. we inherit all values from card's PCM HW, |
|
* but can still override some of the values for the device. |
|
*/ |
|
cfg_read_pcm_hw(device_path, parent_pcm_hw, &pcm_instance->pcm_hw); |
|
|
|
/* Find out how many streams were configured in Xen store. */ |
|
num_streams = 0; |
|
do { |
|
snprintf(node, sizeof(node), "%d", num_streams); |
|
if (!xenbus_exists(XBT_NIL, device_path, node)) |
|
break; |
|
|
|
num_streams++; |
|
} while (num_streams < VSND_MAX_STREAM); |
|
|
|
pcm_instance->num_streams_pb = 0; |
|
pcm_instance->num_streams_cap = 0; |
|
/* Get number of playback and capture streams. */ |
|
for (i = 0; i < num_streams; i++) { |
|
ret = cfg_get_stream_type(device_path, i, &num_pb, &num_cap); |
|
if (ret < 0) |
|
goto fail; |
|
|
|
pcm_instance->num_streams_pb += num_pb; |
|
pcm_instance->num_streams_cap += num_cap; |
|
} |
|
|
|
if (pcm_instance->num_streams_pb) { |
|
pcm_instance->streams_pb = |
|
devm_kcalloc(&front_info->xb_dev->dev, |
|
pcm_instance->num_streams_pb, |
|
sizeof(struct xen_front_cfg_stream), |
|
GFP_KERNEL); |
|
if (!pcm_instance->streams_pb) { |
|
ret = -ENOMEM; |
|
goto fail; |
|
} |
|
} |
|
|
|
if (pcm_instance->num_streams_cap) { |
|
pcm_instance->streams_cap = |
|
devm_kcalloc(&front_info->xb_dev->dev, |
|
pcm_instance->num_streams_cap, |
|
sizeof(struct xen_front_cfg_stream), |
|
GFP_KERNEL); |
|
if (!pcm_instance->streams_cap) { |
|
ret = -ENOMEM; |
|
goto fail; |
|
} |
|
} |
|
|
|
cur_pb = 0; |
|
cur_cap = 0; |
|
for (i = 0; i < num_streams; i++) { |
|
ret = cfg_stream(front_info, pcm_instance, device_path, i, |
|
&cur_pb, &cur_cap, stream_cnt); |
|
if (ret < 0) |
|
goto fail; |
|
} |
|
ret = 0; |
|
|
|
fail: |
|
kfree(device_path); |
|
return ret; |
|
} |
|
|
|
int xen_snd_front_cfg_card(struct xen_snd_front_info *front_info, |
|
int *stream_cnt) |
|
{ |
|
struct xenbus_device *xb_dev = front_info->xb_dev; |
|
struct xen_front_cfg_card *cfg = &front_info->cfg; |
|
int ret, num_devices, i; |
|
char node[3]; |
|
|
|
*stream_cnt = 0; |
|
num_devices = 0; |
|
do { |
|
snprintf(node, sizeof(node), "%d", num_devices); |
|
if (!xenbus_exists(XBT_NIL, xb_dev->nodename, node)) |
|
break; |
|
|
|
num_devices++; |
|
} while (num_devices < SNDRV_PCM_DEVICES); |
|
|
|
if (!num_devices) { |
|
dev_warn(&xb_dev->dev, |
|
"No devices configured for sound card at %s\n", |
|
xb_dev->nodename); |
|
return -ENODEV; |
|
} |
|
|
|
/* Start from default PCM HW configuration for the card. */ |
|
cfg_read_pcm_hw(xb_dev->nodename, NULL, &cfg->pcm_hw); |
|
|
|
cfg->pcm_instances = |
|
devm_kcalloc(&front_info->xb_dev->dev, num_devices, |
|
sizeof(struct xen_front_cfg_pcm_instance), |
|
GFP_KERNEL); |
|
if (!cfg->pcm_instances) |
|
return -ENOMEM; |
|
|
|
for (i = 0; i < num_devices; i++) { |
|
ret = cfg_device(front_info, &cfg->pcm_instances[i], |
|
&cfg->pcm_hw, xb_dev->nodename, i, stream_cnt); |
|
if (ret < 0) |
|
return ret; |
|
} |
|
cfg->num_pcm_instances = num_devices; |
|
return 0; |
|
} |
|
|
|
|