[linux.git] / sound / xen / xen_snd_front_cfg.c

// 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 {
		scnprintf(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;
}
Commit	Line	Data
fd3b3604 OA	1	// SPDX-License-Identifier: GPL-2.0 OR MIT
	2
	3	/*
	4	* Xen para-virtual sound device
	5	*
	6	* Copyright (C) 2016-2018 EPAM Systems Inc.
	7	*
	8	* Author: Oleksandr Andrushchenko <[email protected]>
	9	*/
	10
	11	#include <xen/xenbus.h>
	12
	13	#include <xen/interface/io/sndif.h>
	14
	15	#include "xen_snd_front.h"
	16	#include "xen_snd_front_cfg.h"
	17
	18	/* Maximum number of supported streams. */
	19	#define VSND_MAX_STREAM 8
	20
	21	struct cfg_hw_sample_rate {
	22	const char *name;
	23	unsigned int mask;
	24	unsigned int value;
	25	};
	26
	27	static const struct cfg_hw_sample_rate CFG_HW_SUPPORTED_RATES[] = {
	28	{ .name = "5512", .mask = SNDRV_PCM_RATE_5512, .value = 5512 },
	29	{ .name = "8000", .mask = SNDRV_PCM_RATE_8000, .value = 8000 },
	30	{ .name = "11025", .mask = SNDRV_PCM_RATE_11025, .value = 11025 },
	31	{ .name = "16000", .mask = SNDRV_PCM_RATE_16000, .value = 16000 },
	32	{ .name = "22050", .mask = SNDRV_PCM_RATE_22050, .value = 22050 },
	33	{ .name = "32000", .mask = SNDRV_PCM_RATE_32000, .value = 32000 },
	34	{ .name = "44100", .mask = SNDRV_PCM_RATE_44100, .value = 44100 },
	35	{ .name = "48000", .mask = SNDRV_PCM_RATE_48000, .value = 48000 },
	36	{ .name = "64000", .mask = SNDRV_PCM_RATE_64000, .value = 64000 },
	37	{ .name = "96000", .mask = SNDRV_PCM_RATE_96000, .value = 96000 },
	38	{ .name = "176400", .mask = SNDRV_PCM_RATE_176400, .value = 176400 },
	39	{ .name = "192000", .mask = SNDRV_PCM_RATE_192000, .value = 192000 },
	40	};
	41
	42	struct cfg_hw_sample_format {
	43	const char *name;
	44	u64 mask;
	45	};
	46
	47	static const struct cfg_hw_sample_format CFG_HW_SUPPORTED_FORMATS[] = {
	48	{
	49	.name = XENSND_PCM_FORMAT_U8_STR,
	50	.mask = SNDRV_PCM_FMTBIT_U8
	51	},
	52	{
	53	.name = XENSND_PCM_FORMAT_S8_STR,
	54	.mask = SNDRV_PCM_FMTBIT_S8
	55	},
	56	{
	57	.name = XENSND_PCM_FORMAT_U16_LE_STR,
	58	.mask = SNDRV_PCM_FMTBIT_U16_LE
	59	},
	60	{
	61	.name = XENSND_PCM_FORMAT_U16_BE_STR,
	62	.mask = SNDRV_PCM_FMTBIT_U16_BE
	63	},
	64	{
65	.name = XENSND_PCM_FORMAT_S16_LE_STR,
66	.mask = SNDRV_PCM_FMTBIT_S16_LE
67	},
68	{
69	.name = XENSND_PCM_FORMAT_S16_BE_STR,
70	.mask = SNDRV_PCM_FMTBIT_S16_BE
71	},
72	{
73	.name = XENSND_PCM_FORMAT_U24_LE_STR,
74	.mask = SNDRV_PCM_FMTBIT_U24_LE
75	},
76	{
77	.name = XENSND_PCM_FORMAT_U24_BE_STR,
78	.mask = SNDRV_PCM_FMTBIT_U24_BE
79	},
80	{
81	.name = XENSND_PCM_FORMAT_S24_LE_STR,
82	.mask = SNDRV_PCM_FMTBIT_S24_LE
83	},
84	{
85	.name = XENSND_PCM_FORMAT_S24_BE_STR,
86	.mask = SNDRV_PCM_FMTBIT_S24_BE
87	},
88	{
89	.name = XENSND_PCM_FORMAT_U32_LE_STR,
90	.mask = SNDRV_PCM_FMTBIT_U32_LE
91	},
92	{
93	.name = XENSND_PCM_FORMAT_U32_BE_STR,
94	.mask = SNDRV_PCM_FMTBIT_U32_BE
95	},
96	{
97	.name = XENSND_PCM_FORMAT_S32_LE_STR,
98	.mask = SNDRV_PCM_FMTBIT_S32_LE
99	},
100	{
101	.name = XENSND_PCM_FORMAT_S32_BE_STR,
102	.mask = SNDRV_PCM_FMTBIT_S32_BE
103	},
104	{
105	.name = XENSND_PCM_FORMAT_A_LAW_STR,
106	.mask = SNDRV_PCM_FMTBIT_A_LAW
107	},
108	{
109	.name = XENSND_PCM_FORMAT_MU_LAW_STR,
110	.mask = SNDRV_PCM_FMTBIT_MU_LAW
111	},
112	{
113	.name = XENSND_PCM_FORMAT_F32_LE_STR,
114	.mask = SNDRV_PCM_FMTBIT_FLOAT_LE
115	},
116	{
117	.name = XENSND_PCM_FORMAT_F32_BE_STR,
118	.mask = SNDRV_PCM_FMTBIT_FLOAT_BE
119	},
120	{
121	.name = XENSND_PCM_FORMAT_F64_LE_STR,
122	.mask = SNDRV_PCM_FMTBIT_FLOAT64_LE
123	},
124	{
125	.name = XENSND_PCM_FORMAT_F64_BE_STR,
126	.mask = SNDRV_PCM_FMTBIT_FLOAT64_BE
127	},
128	{
129	.name = XENSND_PCM_FORMAT_IEC958_SUBFRAME_LE_STR,
130	.mask = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
131	},
132	{
133	.name = XENSND_PCM_FORMAT_IEC958_SUBFRAME_BE_STR,
134	.mask = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE
135	},
136	{
137	.name = XENSND_PCM_FORMAT_IMA_ADPCM_STR,
138	.mask = SNDRV_PCM_FMTBIT_IMA_ADPCM
139	},
140	{
141	.name = XENSND_PCM_FORMAT_MPEG_STR,
142	.mask = SNDRV_PCM_FMTBIT_MPEG
143	},
144	{
145	.name = XENSND_PCM_FORMAT_GSM_STR,
146	.mask = SNDRV_PCM_FMTBIT_GSM
147	},
148	};
149
150	static void cfg_hw_rates(char *list, unsigned int len,
151	const char path, struct snd_pcm_hardware pcm_hw)
152	{
153	char *cur_rate;
154	unsigned int cur_mask;
155	unsigned int cur_value;
156	unsigned int rates;
157	unsigned int rate_min;
158	unsigned int rate_max;
159	int i;
160
161	rates = 0;
162	rate_min = -1;
163	rate_max = 0;
164	while ((cur_rate = strsep(&list, XENSND_LIST_SEPARATOR))) {
165	for (i = 0; i < ARRAY_SIZE(CFG_HW_SUPPORTED_RATES); i++)
166	if (!strncasecmp(cur_rate,
167	CFG_HW_SUPPORTED_RATES[i].name,
168	XENSND_SAMPLE_RATE_MAX_LEN)) {
169	cur_mask = CFG_HW_SUPPORTED_RATES[i].mask;
170	cur_value = CFG_HW_SUPPORTED_RATES[i].value;
171	rates \|= cur_mask;
172	if (rate_min > cur_value)
173	rate_min = cur_value;
174	if (rate_max < cur_value)
175	rate_max = cur_value;
176	}
177	}
178
179	if (rates) {
180	pcm_hw->rates = rates;
181	pcm_hw->rate_min = rate_min;
182	pcm_hw->rate_max = rate_max;
183	}
184	}
185
186	static void cfg_formats(char *list, unsigned int len,
187	const char path, struct snd_pcm_hardware pcm_hw)
188	{
189	u64 formats;
190	char *cur_format;
191	int i;
192
193	formats = 0;
194	while ((cur_format = strsep(&list, XENSND_LIST_SEPARATOR))) {
195	for (i = 0; i < ARRAY_SIZE(CFG_HW_SUPPORTED_FORMATS); i++)
196	if (!strncasecmp(cur_format,
197	CFG_HW_SUPPORTED_FORMATS[i].name,
198	XENSND_SAMPLE_FORMAT_MAX_LEN))
199	formats \|= CFG_HW_SUPPORTED_FORMATS[i].mask;
200	}
201
202	if (formats)
203	pcm_hw->formats = formats;
204	}
205
206	#define MAX_BUFFER_SIZE (64 * 1024)
207	#define MIN_PERIOD_SIZE 64
208	#define MAX_PERIOD_SIZE MAX_BUFFER_SIZE
209	#define USE_FORMATS (SNDRV_PCM_FMTBIT_U8 \| \
210	SNDRV_PCM_FMTBIT_S16_LE)
211	#define USE_RATE (SNDRV_PCM_RATE_CONTINUOUS \| \
212	SNDRV_PCM_RATE_8000_48000)
213	#define USE_RATE_MIN 5512
214	#define USE_RATE_MAX 48000
215	#define USE_CHANNELS_MIN 1
216	#define USE_CHANNELS_MAX 2
217	#define USE_PERIODS_MIN 2
218	#define USE_PERIODS_MAX (MAX_BUFFER_SIZE / MIN_PERIOD_SIZE)
219
220	static const struct snd_pcm_hardware SND_DRV_PCM_HW_DEFAULT = {
221	.info = (SNDRV_PCM_INFO_MMAP \|
222	SNDRV_PCM_INFO_INTERLEAVED \|
223	SNDRV_PCM_INFO_RESUME \|
224	SNDRV_PCM_INFO_MMAP_VALID),
225	.formats = USE_FORMATS,
226	.rates = USE_RATE,
227	.rate_min = USE_RATE_MIN,
228	.rate_max = USE_RATE_MAX,
229	.channels_min = USE_CHANNELS_MIN,
230	.channels_max = USE_CHANNELS_MAX,
231	.buffer_bytes_max = MAX_BUFFER_SIZE,
232	.period_bytes_min = MIN_PERIOD_SIZE,
233	.period_bytes_max = MAX_PERIOD_SIZE,
234	.periods_min = USE_PERIODS_MIN,
235	.periods_max = USE_PERIODS_MAX,
236	.fifo_size = 0,
237	};
238
239	static void cfg_read_pcm_hw(const char *path,
240	struct snd_pcm_hardware *parent_pcm_hw,
241	struct snd_pcm_hardware *pcm_hw)
242	{
243	char *list;
244	int val;
245	size_t buf_sz;
246	unsigned int len;
247
248	/* Inherit parent's PCM HW and read overrides from XenStore. */
249	if (parent_pcm_hw)
250	pcm_hw = parent_pcm_hw;
251	else
252	*pcm_hw = SND_DRV_PCM_HW_DEFAULT;
253
254	val = xenbus_read_unsigned(path, XENSND_FIELD_CHANNELS_MIN, 0);
255	if (val)
256	pcm_hw->channels_min = val;
257
258	val = xenbus_read_unsigned(path, XENSND_FIELD_CHANNELS_MAX, 0);
259	if (val)
260	pcm_hw->channels_max = val;
261
262	list = xenbus_read(XBT_NIL, path, XENSND_FIELD_SAMPLE_RATES, &len);
263	if (!IS_ERR(list)) {
264	cfg_hw_rates(list, len, path, pcm_hw);
265	kfree(list);
266	}
267
268	list = xenbus_read(XBT_NIL, path, XENSND_FIELD_SAMPLE_FORMATS, &len);
269	if (!IS_ERR(list)) {
270	cfg_formats(list, len, path, pcm_hw);
271	kfree(list);
272	}
273
274	buf_sz = xenbus_read_unsigned(path, XENSND_FIELD_BUFFER_SIZE, 0);
275	if (buf_sz)
276	pcm_hw->buffer_bytes_max = buf_sz;
277
278	/* Update configuration to match new values. */
279	if (pcm_hw->channels_min > pcm_hw->channels_max)
280	pcm_hw->channels_min = pcm_hw->channels_max;
281
282	if (pcm_hw->rate_min > pcm_hw->rate_max)
283	pcm_hw->rate_min = pcm_hw->rate_max;
284
285	pcm_hw->period_bytes_max = pcm_hw->buffer_bytes_max;
286
287	pcm_hw->periods_max = pcm_hw->period_bytes_max /
288	pcm_hw->period_bytes_min;
289	}
290
291	static int cfg_get_stream_type(const char *path, int index,
292	int num_pb, int num_cap)
293	{
294	char *str = NULL;
295	char *stream_path;
296	int ret;
297
298	*num_pb = 0;
299	*num_cap = 0;
300	stream_path = kasprintf(GFP_KERNEL, "%s/%d", path, index);
301	if (!stream_path) {
302	ret = -ENOMEM;
303	goto fail;
304	}
305
306	str = xenbus_read(XBT_NIL, stream_path, XENSND_FIELD_TYPE, NULL);
307	if (IS_ERR(str)) {
308	ret = PTR_ERR(str);
e46dcbb1	309	str = NULL;
fd3b3604 OA	310	goto fail;
	311	}
	312
	313	if (!strncasecmp(str, XENSND_STREAM_TYPE_PLAYBACK,
	314	sizeof(XENSND_STREAM_TYPE_PLAYBACK))) {
	315	(*num_pb)++;
	316	} else if (!strncasecmp(str, XENSND_STREAM_TYPE_CAPTURE,
	317	sizeof(XENSND_STREAM_TYPE_CAPTURE))) {
	318	(*num_cap)++;
	319	} else {
	320	ret = -EINVAL;
	321	goto fail;
	322	}
	323	ret = 0;
	324
	325	fail:
	326	kfree(stream_path);
	327	kfree(str);
	328	return ret;
	329	}
	330
	331	static int cfg_stream(struct xen_snd_front_info *front_info,
	332	struct xen_front_cfg_pcm_instance *pcm_instance,
	333	const char path, int index, int cur_pb, int *cur_cap,
	334	int *stream_cnt)
	335	{
	336	char *str = NULL;
	337	char *stream_path;
	338	struct xen_front_cfg_stream *stream;
	339	int ret;
	340
	341	stream_path = devm_kasprintf(&front_info->xb_dev->dev,
	342	GFP_KERNEL, "%s/%d", path, index);
	343	if (!stream_path) {
	344	ret = -ENOMEM;
	345	goto fail;
	346	}
	347
	348	str = xenbus_read(XBT_NIL, stream_path, XENSND_FIELD_TYPE, NULL);
	349	if (IS_ERR(str)) {
	350	ret = PTR_ERR(str);
e46dcbb1	351	str = NULL;
fd3b3604 OA	352	goto fail;
	353	}
	354
	355	if (!strncasecmp(str, XENSND_STREAM_TYPE_PLAYBACK,
	356	sizeof(XENSND_STREAM_TYPE_PLAYBACK))) {
	357	stream = &pcm_instance->streams_pb[(*cur_pb)++];
	358	} else if (!strncasecmp(str, XENSND_STREAM_TYPE_CAPTURE,
	359	sizeof(XENSND_STREAM_TYPE_CAPTURE))) {
	360	stream = &pcm_instance->streams_cap[(*cur_cap)++];
	361	} else {
	362	ret = -EINVAL;
	363	goto fail;
	364	}
	365
	366	/* Get next stream index. */
	367	stream->index = (*stream_cnt)++;
	368	stream->xenstore_path = stream_path;
	369	/*
	370	* Check XenStore if PCM HW configuration exists for this stream
	371	* and update if so, e.g. we inherit all values from device's PCM HW,
	372	* but can still override some of the values for the stream.
	373	*/
	374	cfg_read_pcm_hw(stream->xenstore_path,
	375	&pcm_instance->pcm_hw, &stream->pcm_hw);
	376	ret = 0;
	377
	378	fail:
	379	kfree(str);
	380	return ret;
	381	}
	382
	383	static int cfg_device(struct xen_snd_front_info *front_info,
	384	struct xen_front_cfg_pcm_instance *pcm_instance,
	385	struct snd_pcm_hardware *parent_pcm_hw,
	386	const char path, int node_index, int stream_cnt)
	387	{
	388	char *str;
	389	char *device_path;
	390	int ret, i, num_streams;
	391	int num_pb, num_cap;
	392	int cur_pb, cur_cap;
	393	char node[3];
	394
	395	device_path = kasprintf(GFP_KERNEL, "%s/%d", path, node_index);
	396	if (!device_path)
	397	return -ENOMEM;
	398
	399	str = xenbus_read(XBT_NIL, device_path, XENSND_FIELD_DEVICE_NAME, NULL);
	400	if (!IS_ERR(str)) {
75b1a8f9	401	strscpy(pcm_instance->name, str, sizeof(pcm_instance->name));
fd3b3604 OA	402	kfree(str);
	403	}
	404
	405	pcm_instance->device_id = node_index;
	406
	407	/*
	408	* Check XenStore if PCM HW configuration exists for this device
	409	* and update if so, e.g. we inherit all values from card's PCM HW,
	410	* but can still override some of the values for the device.
	411	*/
	412	cfg_read_pcm_hw(device_path, parent_pcm_hw, &pcm_instance->pcm_hw);
	413
	414	/* Find out how many streams were configured in Xen store. */
	415	num_streams = 0;
	416	do {
	417	snprintf(node, sizeof(node), "%d", num_streams);
	418	if (!xenbus_exists(XBT_NIL, device_path, node))
	419	break;
	420
	421	num_streams++;
	422	} while (num_streams < VSND_MAX_STREAM);
	423
	424	pcm_instance->num_streams_pb = 0;
	425	pcm_instance->num_streams_cap = 0;
	426	/* Get number of playback and capture streams. */
	427	for (i = 0; i < num_streams; i++) {
	428	ret = cfg_get_stream_type(device_path, i, &num_pb, &num_cap);
	429	if (ret < 0)
	430	goto fail;
	431
	432	pcm_instance->num_streams_pb += num_pb;
	433	pcm_instance->num_streams_cap += num_cap;
	434	}
	435
	436	if (pcm_instance->num_streams_pb) {
	437	pcm_instance->streams_pb =
	438	devm_kcalloc(&front_info->xb_dev->dev,
	439	pcm_instance->num_streams_pb,
	440	sizeof(struct xen_front_cfg_stream),
	441	GFP_KERNEL);
	442	if (!pcm_instance->streams_pb) {
	443	ret = -ENOMEM;
	444	goto fail;
	445	}
	446	}
	447
	448	if (pcm_instance->num_streams_cap) {
	449	pcm_instance->streams_cap =
	450	devm_kcalloc(&front_info->xb_dev->dev,
	451	pcm_instance->num_streams_cap,
	452	sizeof(struct xen_front_cfg_stream),
	453	GFP_KERNEL);
	454	if (!pcm_instance->streams_cap) {
	455	ret = -ENOMEM;
	456	goto fail;
	457	}
	458	}
	459
	460	cur_pb = 0;
	461	cur_cap = 0;
	462	for (i = 0; i < num_streams; i++) {
	463	ret = cfg_stream(front_info, pcm_instance, device_path, i,
	464	&cur_pb, &cur_cap, stream_cnt);
	465	if (ret < 0)
466	goto fail;
467	}
468	ret = 0;
469
470	fail:
471	kfree(device_path);
472	return ret;
473	}
474
475	int xen_snd_front_cfg_card(struct xen_snd_front_info *front_info,
476	int *stream_cnt)
477	{
478	struct xenbus_device *xb_dev = front_info->xb_dev;
479	struct xen_front_cfg_card *cfg = &front_info->cfg;
480	int ret, num_devices, i;
481	char node[3];
482
483	*stream_cnt = 0;
484	num_devices = 0;
485	do {
7272b8bf	486	scnprintf(node, sizeof(node), "%d", num_devices);
fd3b3604 OA	487	if (!xenbus_exists(XBT_NIL, xb_dev->nodename, node))
	488	break;
	489
	490	num_devices++;
	491	} while (num_devices < SNDRV_PCM_DEVICES);
	492
	493	if (!num_devices) {
	494	dev_warn(&xb_dev->dev,
	495	"No devices configured for sound card at %s\n",
	496	xb_dev->nodename);
	497	return -ENODEV;
	498	}
	499
	500	/* Start from default PCM HW configuration for the card. */
	501	cfg_read_pcm_hw(xb_dev->nodename, NULL, &cfg->pcm_hw);
	502
	503	cfg->pcm_instances =
	504	devm_kcalloc(&front_info->xb_dev->dev, num_devices,
	505	sizeof(struct xen_front_cfg_pcm_instance),
	506	GFP_KERNEL);
	507	if (!cfg->pcm_instances)
	508	return -ENOMEM;
	509
	510	for (i = 0; i < num_devices; i++) {
	511	ret = cfg_device(front_info, &cfg->pcm_instances[i],
	512	&cfg->pcm_hw, xb_dev->nodename, i, stream_cnt);
	513	if (ret < 0)
	514	return ret;
	515	}
	516	cfg->num_pcm_instances = num_devices;
	517	return 0;
	518	}
	519