[linux-2.6-block.git] / sound / virtio / virtio_card.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * virtio-snd: Virtio sound device
 * Copyright (C) 2021 OpenSynergy GmbH
 */
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/virtio_config.h>
#include <sound/initval.h>
#include <uapi/linux/virtio_ids.h>

#include "virtio_card.h"

u32 virtsnd_msg_timeout_ms = MSEC_PER_SEC;
module_param_named(msg_timeout_ms, virtsnd_msg_timeout_ms, uint, 0644);
MODULE_PARM_DESC(msg_timeout_ms, "Message completion timeout in milliseconds");

static void virtsnd_remove(struct virtio_device *vdev);

/**
 * virtsnd_event_send() - Add an event to the event queue.
 * @vqueue: Underlying event virtqueue.
 * @event: Event.
 * @notify: Indicates whether or not to send a notification to the device.
 * @gfp: Kernel flags for memory allocation.
 *
 * Context: Any context.
 */
static void virtsnd_event_send(struct virtqueue *vqueue,
			       struct virtio_snd_event *event, bool notify,
			       gfp_t gfp)
{
	struct scatterlist sg;
	struct scatterlist *psgs[1] = { &sg };

	/* reset event content */
	memset(event, 0, sizeof(*event));

	sg_init_one(&sg, event, sizeof(*event));

	if (virtqueue_add_sgs(vqueue, psgs, 0, 1, event, gfp) || !notify)
		return;

	if (virtqueue_kick_prepare(vqueue))
		virtqueue_notify(vqueue);
}

/**
 * virtsnd_event_dispatch() - Dispatch an event from the device side.
 * @snd: VirtIO sound device.
 * @event: VirtIO sound event.
 *
 * Context: Any context.
 */
static void virtsnd_event_dispatch(struct virtio_snd *snd,
				   struct virtio_snd_event *event)
{
	switch (le32_to_cpu(event->hdr.code)) {
	case VIRTIO_SND_EVT_JACK_CONNECTED:
	case VIRTIO_SND_EVT_JACK_DISCONNECTED:
		virtsnd_jack_event(snd, event);
		break;
	case VIRTIO_SND_EVT_PCM_PERIOD_ELAPSED:
	case VIRTIO_SND_EVT_PCM_XRUN:
		virtsnd_pcm_event(snd, event);
		break;
	}
}

/**
 * virtsnd_event_notify_cb() - Dispatch all reported events from the event queue.
 * @vqueue: Underlying event virtqueue.
 *
 * This callback function is called upon a vring interrupt request from the
 * device.
 *
 * Context: Interrupt context.
 */
static void virtsnd_event_notify_cb(struct virtqueue *vqueue)
{
	struct virtio_snd *snd = vqueue->vdev->priv;
	struct virtio_snd_queue *queue = virtsnd_event_queue(snd);
	struct virtio_snd_event *event;
	u32 length;
	unsigned long flags;

	spin_lock_irqsave(&queue->lock, flags);
	do {
		virtqueue_disable_cb(vqueue);
		while ((event = virtqueue_get_buf(vqueue, &length))) {
			virtsnd_event_dispatch(snd, event);
			virtsnd_event_send(vqueue, event, true, GFP_ATOMIC);
		}
		if (unlikely(virtqueue_is_broken(vqueue)))
			break;
	} while (!virtqueue_enable_cb(vqueue));
	spin_unlock_irqrestore(&queue->lock, flags);
}

/**
 * virtsnd_find_vqs() - Enumerate and initialize all virtqueues.
 * @snd: VirtIO sound device.
 *
 * After calling this function, the event queue is disabled.
 *
 * Context: Any context.
 * Return: 0 on success, -errno on failure.
 */
static int virtsnd_find_vqs(struct virtio_snd *snd)
{
	struct virtio_device *vdev = snd->vdev;
	static vq_callback_t *callbacks[VIRTIO_SND_VQ_MAX] = {
		[VIRTIO_SND_VQ_CONTROL] = virtsnd_ctl_notify_cb,
		[VIRTIO_SND_VQ_EVENT] = virtsnd_event_notify_cb,
		[VIRTIO_SND_VQ_TX] = virtsnd_pcm_tx_notify_cb,
		[VIRTIO_SND_VQ_RX] = virtsnd_pcm_rx_notify_cb
	};
	static const char *names[VIRTIO_SND_VQ_MAX] = {
		[VIRTIO_SND_VQ_CONTROL] = "virtsnd-ctl",
		[VIRTIO_SND_VQ_EVENT] = "virtsnd-event",
		[VIRTIO_SND_VQ_TX] = "virtsnd-tx",
		[VIRTIO_SND_VQ_RX] = "virtsnd-rx"
	};
	struct virtqueue *vqs[VIRTIO_SND_VQ_MAX] = { 0 };
	unsigned int i;
	unsigned int n;
	int rc;

	rc = virtio_find_vqs(vdev, VIRTIO_SND_VQ_MAX, vqs, callbacks, names,
			     NULL);
	if (rc) {
		dev_err(&vdev->dev, "failed to initialize virtqueues\n");
		return rc;
	}

	for (i = 0; i < VIRTIO_SND_VQ_MAX; ++i)
		snd->queues[i].vqueue = vqs[i];

	/* Allocate events and populate the event queue */
	virtqueue_disable_cb(vqs[VIRTIO_SND_VQ_EVENT]);

	n = virtqueue_get_vring_size(vqs[VIRTIO_SND_VQ_EVENT]);

	snd->event_msgs = kmalloc_array(n, sizeof(*snd->event_msgs),
					GFP_KERNEL);
	if (!snd->event_msgs)
		return -ENOMEM;

	for (i = 0; i < n; ++i)
		virtsnd_event_send(vqs[VIRTIO_SND_VQ_EVENT],
				   &snd->event_msgs[i], false, GFP_KERNEL);

	return 0;
}

/**
 * virtsnd_enable_event_vq() - Enable the event virtqueue.
 * @snd: VirtIO sound device.
 *
 * Context: Any context.
 */
static void virtsnd_enable_event_vq(struct virtio_snd *snd)
{
	struct virtio_snd_queue *queue = virtsnd_event_queue(snd);

	if (!virtqueue_enable_cb(queue->vqueue))
		virtsnd_event_notify_cb(queue->vqueue);
}

/**
 * virtsnd_disable_event_vq() - Disable the event virtqueue.
 * @snd: VirtIO sound device.
 *
 * Context: Any context.
 */
static void virtsnd_disable_event_vq(struct virtio_snd *snd)
{
	struct virtio_snd_queue *queue = virtsnd_event_queue(snd);
	struct virtio_snd_event *event;
	u32 length;
	unsigned long flags;

	if (queue->vqueue) {
		spin_lock_irqsave(&queue->lock, flags);
		virtqueue_disable_cb(queue->vqueue);
		while ((event = virtqueue_get_buf(queue->vqueue, &length)))
			virtsnd_event_dispatch(snd, event);
		spin_unlock_irqrestore(&queue->lock, flags);
	}
}

/**
 * virtsnd_build_devs() - Read configuration and build ALSA devices.
 * @snd: VirtIO sound device.
 *
 * Context: Any context that permits to sleep.
 * Return: 0 on success, -errno on failure.
 */
static int virtsnd_build_devs(struct virtio_snd *snd)
{
	struct virtio_device *vdev = snd->vdev;
	struct device *dev = &vdev->dev;
	int rc;

	rc = snd_card_new(dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
			  THIS_MODULE, 0, &snd->card);
	if (rc < 0)
		return rc;

	snd->card->private_data = snd;

	strscpy(snd->card->driver, VIRTIO_SND_CARD_DRIVER,
		sizeof(snd->card->driver));
	strscpy(snd->card->shortname, VIRTIO_SND_CARD_NAME,
		sizeof(snd->card->shortname));
	if (dev->parent->bus)
		snprintf(snd->card->longname, sizeof(snd->card->longname),
			 VIRTIO_SND_CARD_NAME " at %s/%s/%s",
			 dev->parent->bus->name, dev_name(dev->parent),
			 dev_name(dev));
	else
		snprintf(snd->card->longname, sizeof(snd->card->longname),
			 VIRTIO_SND_CARD_NAME " at %s/%s",
			 dev_name(dev->parent), dev_name(dev));

	rc = virtsnd_jack_parse_cfg(snd);
	if (rc)
		return rc;

	rc = virtsnd_pcm_parse_cfg(snd);
	if (rc)
		return rc;

	rc = virtsnd_chmap_parse_cfg(snd);
	if (rc)
		return rc;

	if (snd->njacks) {
		rc = virtsnd_jack_build_devs(snd);
		if (rc)
			return rc;
	}

	if (snd->nsubstreams) {
		rc = virtsnd_pcm_build_devs(snd);
		if (rc)
			return rc;
	}

	if (snd->nchmaps) {
		rc = virtsnd_chmap_build_devs(snd);
		if (rc)
			return rc;
	}

	return snd_card_register(snd->card);
}

/**
 * virtsnd_validate() - Validate if the device can be started.
 * @vdev: VirtIO parent device.
 *
 * Context: Any context.
 * Return: 0 on success, -EINVAL on failure.
 */
static int virtsnd_validate(struct virtio_device *vdev)
{
	if (!vdev->config->get) {
		dev_err(&vdev->dev, "configuration access disabled\n");
		return -EINVAL;
	}

	if (!virtio_has_feature(vdev, VIRTIO_F_VERSION_1)) {
		dev_err(&vdev->dev,
			"device does not comply with spec version 1.x\n");
		return -EINVAL;
	}

	if (!virtsnd_msg_timeout_ms) {
		dev_err(&vdev->dev, "msg_timeout_ms value cannot be zero\n");
		return -EINVAL;
	}

	if (virtsnd_pcm_validate(vdev))
		return -EINVAL;

	return 0;
}

/**
 * virtsnd_probe() - Create and initialize the device.
 * @vdev: VirtIO parent device.
 *
 * Context: Any context that permits to sleep.
 * Return: 0 on success, -errno on failure.
 */
static int virtsnd_probe(struct virtio_device *vdev)
{
	struct virtio_snd *snd;
	unsigned int i;
	int rc;

	snd = devm_kzalloc(&vdev->dev, sizeof(*snd), GFP_KERNEL);
	if (!snd)
		return -ENOMEM;

	snd->vdev = vdev;
	INIT_LIST_HEAD(&snd->ctl_msgs);
	INIT_LIST_HEAD(&snd->pcm_list);

	vdev->priv = snd;

	for (i = 0; i < VIRTIO_SND_VQ_MAX; ++i)
		spin_lock_init(&snd->queues[i].lock);

	rc = virtsnd_find_vqs(snd);
	if (rc)
		goto on_exit;

	virtio_device_ready(vdev);

	rc = virtsnd_build_devs(snd);
	if (rc)
		goto on_exit;

	virtsnd_enable_event_vq(snd);

on_exit:
	if (rc)
		virtsnd_remove(vdev);

	return rc;
}

/**
 * virtsnd_remove() - Remove VirtIO and ALSA devices.
 * @vdev: VirtIO parent device.
 *
 * Context: Any context that permits to sleep.
 */
static void virtsnd_remove(struct virtio_device *vdev)
{
	struct virtio_snd *snd = vdev->priv;
	unsigned int i;

	virtsnd_disable_event_vq(snd);
	virtsnd_ctl_msg_cancel_all(snd);

	if (snd->card)
		snd_card_free(snd->card);

	vdev->config->del_vqs(vdev);
	virtio_reset_device(vdev);

	for (i = 0; snd->substreams && i < snd->nsubstreams; ++i) {
		struct virtio_pcm_substream *vss = &snd->substreams[i];

		cancel_work_sync(&vss->elapsed_period);
		virtsnd_pcm_msg_free(vss);
	}

	kfree(snd->event_msgs);
}

#ifdef CONFIG_PM_SLEEP
/**
 * virtsnd_freeze() - Suspend device.
 * @vdev: VirtIO parent device.
 *
 * Context: Any context.
 * Return: 0 on success, -errno on failure.
 */
static int virtsnd_freeze(struct virtio_device *vdev)
{
	struct virtio_snd *snd = vdev->priv;
	unsigned int i;

	virtsnd_disable_event_vq(snd);
	virtsnd_ctl_msg_cancel_all(snd);

	vdev->config->del_vqs(vdev);
	virtio_reset_device(vdev);

	for (i = 0; i < snd->nsubstreams; ++i)
		cancel_work_sync(&snd->substreams[i].elapsed_period);

	kfree(snd->event_msgs);
	snd->event_msgs = NULL;

	return 0;
}

/**
 * virtsnd_restore() - Resume device.
 * @vdev: VirtIO parent device.
 *
 * Context: Any context.
 * Return: 0 on success, -errno on failure.
 */
static int virtsnd_restore(struct virtio_device *vdev)
{
	struct virtio_snd *snd = vdev->priv;
	int rc;

	rc = virtsnd_find_vqs(snd);
	if (rc)
		return rc;

	virtio_device_ready(vdev);

	virtsnd_enable_event_vq(snd);

	return 0;
}
#endif /* CONFIG_PM_SLEEP */

static const struct virtio_device_id id_table[] = {
	{ VIRTIO_ID_SOUND, VIRTIO_DEV_ANY_ID },
	{ 0 },
};

static struct virtio_driver virtsnd_driver = {
	.driver.name = KBUILD_MODNAME,
	.driver.owner = THIS_MODULE,
	.id_table = id_table,
	.validate = virtsnd_validate,
	.probe = virtsnd_probe,
	.remove = virtsnd_remove,
#ifdef CONFIG_PM_SLEEP
	.freeze = virtsnd_freeze,
	.restore = virtsnd_restore,
#endif
};

module_virtio_driver(virtsnd_driver);

MODULE_DEVICE_TABLE(virtio, id_table);
MODULE_DESCRIPTION("Virtio sound card driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
de3a9980 AY	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* virtio-snd: Virtio sound device
	4	* Copyright (C) 2021 OpenSynergy GmbH
	5	*/
	6	#include <linux/module.h>
	7	#include <linux/moduleparam.h>
	8	#include <linux/virtio_config.h>
	9	#include <sound/initval.h>
	10	#include <uapi/linux/virtio_ids.h>
	11
	12	#include "virtio_card.h"
	13
9d45e514 AY	14	u32 virtsnd_msg_timeout_ms = MSEC_PER_SEC;
	15	module_param_named(msg_timeout_ms, virtsnd_msg_timeout_ms, uint, 0644);
	16	MODULE_PARM_DESC(msg_timeout_ms, "Message completion timeout in milliseconds");
	17
de3a9980 AY	18	static void virtsnd_remove(struct virtio_device *vdev);
	19
	20	/**
	21	* virtsnd_event_send() - Add an event to the event queue.
	22	* @vqueue: Underlying event virtqueue.
	23	* @event: Event.
	24	* @notify: Indicates whether or not to send a notification to the device.
	25	* @gfp: Kernel flags for memory allocation.
	26	*
	27	* Context: Any context.
	28	*/
	29	static void virtsnd_event_send(struct virtqueue *vqueue,
	30	struct virtio_snd_event *event, bool notify,
	31	gfp_t gfp)
	32	{
	33	struct scatterlist sg;
	34	struct scatterlist *psgs[1] = { &sg };
	35
	36	/* reset event content */
	37	memset(event, 0, sizeof(*event));
	38
	39	sg_init_one(&sg, event, sizeof(*event));
	40
	41	if (virtqueue_add_sgs(vqueue, psgs, 0, 1, event, gfp) \|\| !notify)
	42	return;
	43
	44	if (virtqueue_kick_prepare(vqueue))
	45	virtqueue_notify(vqueue);
	46	}
	47
	48	/**
	49	* virtsnd_event_dispatch() - Dispatch an event from the device side.
	50	* @snd: VirtIO sound device.
	51	* @event: VirtIO sound event.
	52	*
	53	* Context: Any context.
	54	*/
	55	static void virtsnd_event_dispatch(struct virtio_snd *snd,
	56	struct virtio_snd_event *event)
	57	{
f40a2867	58	switch (le32_to_cpu(event->hdr.code)) {
ca61a41f AY	59	case VIRTIO_SND_EVT_JACK_CONNECTED:
	60	case VIRTIO_SND_EVT_JACK_DISCONNECTED:
	61	virtsnd_jack_event(snd, event);
	62	break;
f40a2867 AY	63	case VIRTIO_SND_EVT_PCM_PERIOD_ELAPSED:
	64	case VIRTIO_SND_EVT_PCM_XRUN:
	65	virtsnd_pcm_event(snd, event);
	66	break;
	67	}
de3a9980 AY	68	}
	69
	70	/**
	71	* virtsnd_event_notify_cb() - Dispatch all reported events from the event queue.
	72	* @vqueue: Underlying event virtqueue.
	73	*
	74	* This callback function is called upon a vring interrupt request from the
	75	* device.
	76	*
	77	* Context: Interrupt context.
	78	*/
	79	static void virtsnd_event_notify_cb(struct virtqueue *vqueue)
	80	{
	81	struct virtio_snd *snd = vqueue->vdev->priv;
	82	struct virtio_snd_queue *queue = virtsnd_event_queue(snd);
	83	struct virtio_snd_event *event;
	84	u32 length;
	85	unsigned long flags;
	86
	87	spin_lock_irqsave(&queue->lock, flags);
	88	do {
	89	virtqueue_disable_cb(vqueue);
	90	while ((event = virtqueue_get_buf(vqueue, &length))) {
	91	virtsnd_event_dispatch(snd, event);
	92	virtsnd_event_send(vqueue, event, true, GFP_ATOMIC);
	93	}
	94	if (unlikely(virtqueue_is_broken(vqueue)))
	95	break;
	96	} while (!virtqueue_enable_cb(vqueue));
	97	spin_unlock_irqrestore(&queue->lock, flags);
	98	}
	99
	100	/**
	101	* virtsnd_find_vqs() - Enumerate and initialize all virtqueues.
	102	* @snd: VirtIO sound device.
	103	*
	104	* After calling this function, the event queue is disabled.
	105	*
	106	* Context: Any context.
	107	* Return: 0 on success, -errno on failure.
	108	*/
	109	static int virtsnd_find_vqs(struct virtio_snd *snd)
	110	{
	111	struct virtio_device *vdev = snd->vdev;
	112	static vq_callback_t *callbacks[VIRTIO_SND_VQ_MAX] = {
9d45e514	113	[VIRTIO_SND_VQ_CONTROL] = virtsnd_ctl_notify_cb,
f40a2867 AY	114	[VIRTIO_SND_VQ_EVENT] = virtsnd_event_notify_cb,
	115	[VIRTIO_SND_VQ_TX] = virtsnd_pcm_tx_notify_cb,
	116	[VIRTIO_SND_VQ_RX] = virtsnd_pcm_rx_notify_cb
de3a9980 AY	117	};
de3a9980 AY	118	static const char *names[VIRTIO_SND_VQ_MAX] = {
9d45e514	119	[VIRTIO_SND_VQ_CONTROL] = "virtsnd-ctl",
f40a2867 AY	120	[VIRTIO_SND_VQ_EVENT] = "virtsnd-event",
	121	[VIRTIO_SND_VQ_TX] = "virtsnd-tx",
	122	[VIRTIO_SND_VQ_RX] = "virtsnd-rx"
de3a9980 AY	123	};
	124	struct virtqueue *vqs[VIRTIO_SND_VQ_MAX] = { 0 };
	125	unsigned int i;
	126	unsigned int n;
	127	int rc;
	128
	129	rc = virtio_find_vqs(vdev, VIRTIO_SND_VQ_MAX, vqs, callbacks, names,
	130	NULL);
	131	if (rc) {
	132	dev_err(&vdev->dev, "failed to initialize virtqueues\n");
	133	return rc;
	134	}
	135
	136	for (i = 0; i < VIRTIO_SND_VQ_MAX; ++i)
	137	snd->queues[i].vqueue = vqs[i];
	138
	139	/* Allocate events and populate the event queue */
	140	virtqueue_disable_cb(vqs[VIRTIO_SND_VQ_EVENT]);
	141
	142	n = virtqueue_get_vring_size(vqs[VIRTIO_SND_VQ_EVENT]);
	143
	144	snd->event_msgs = kmalloc_array(n, sizeof(*snd->event_msgs),
	145	GFP_KERNEL);
	146	if (!snd->event_msgs)
	147	return -ENOMEM;
	148
	149	for (i = 0; i < n; ++i)
	150	virtsnd_event_send(vqs[VIRTIO_SND_VQ_EVENT],
	151	&snd->event_msgs[i], false, GFP_KERNEL);
	152
	153	return 0;
	154	}
	155
	156	/**
	157	* virtsnd_enable_event_vq() - Enable the event virtqueue.
	158	* @snd: VirtIO sound device.
	159	*
	160	* Context: Any context.
	161	*/
	162	static void virtsnd_enable_event_vq(struct virtio_snd *snd)
	163	{
	164	struct virtio_snd_queue *queue = virtsnd_event_queue(snd);
	165
	166	if (!virtqueue_enable_cb(queue->vqueue))
	167	virtsnd_event_notify_cb(queue->vqueue);
	168	}
	169
	170	/**
	171	* virtsnd_disable_event_vq() - Disable the event virtqueue.
	172	* @snd: VirtIO sound device.
	173	*
	174	* Context: Any context.
	175	*/
	176	static void virtsnd_disable_event_vq(struct virtio_snd *snd)
	177	{
	178	struct virtio_snd_queue *queue = virtsnd_event_queue(snd);
	179	struct virtio_snd_event *event;
	180	u32 length;
	181	unsigned long flags;
	182
	183	if (queue->vqueue) {
	184	spin_lock_irqsave(&queue->lock, flags);
	185	virtqueue_disable_cb(queue->vqueue);
	186	while ((event = virtqueue_get_buf(queue->vqueue, &length)))
187	virtsnd_event_dispatch(snd, event);
188	spin_unlock_irqrestore(&queue->lock, flags);
189	}
190	}
191
192	/**
193	* virtsnd_build_devs() - Read configuration and build ALSA devices.
194	* @snd: VirtIO sound device.
195	*
196	* Context: Any context that permits to sleep.
197	* Return: 0 on success, -errno on failure.
198	*/
199	static int virtsnd_build_devs(struct virtio_snd *snd)
200	{
201	struct virtio_device *vdev = snd->vdev;
202	struct device *dev = &vdev->dev;
203	int rc;
204
205	rc = snd_card_new(dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
206	THIS_MODULE, 0, &snd->card);
207	if (rc < 0)
208	return rc;
209
210	snd->card->private_data = snd;
211
212	strscpy(snd->card->driver, VIRTIO_SND_CARD_DRIVER,
213	sizeof(snd->card->driver));
214	strscpy(snd->card->shortname, VIRTIO_SND_CARD_NAME,
215	sizeof(snd->card->shortname));
216	if (dev->parent->bus)
217	snprintf(snd->card->longname, sizeof(snd->card->longname),
218	VIRTIO_SND_CARD_NAME " at %s/%s/%s",
219	dev->parent->bus->name, dev_name(dev->parent),
220	dev_name(dev));
221	else
222	snprintf(snd->card->longname, sizeof(snd->card->longname),
223	VIRTIO_SND_CARD_NAME " at %s/%s",
224	dev_name(dev->parent), dev_name(dev));
225
ca61a41f AY	226	rc = virtsnd_jack_parse_cfg(snd);
	227	if (rc)
	228	return rc;
	229
29b96bf5 AY	230	rc = virtsnd_pcm_parse_cfg(snd);
	231	if (rc)
	232	return rc;
	233
19325fed AY	234	rc = virtsnd_chmap_parse_cfg(snd);
	235	if (rc)
	236	return rc;
	237
ca61a41f AY	238	if (snd->njacks) {
	239	rc = virtsnd_jack_build_devs(snd);
	240	if (rc)
	241	return rc;
	242	}
	243
29b96bf5 AY	244	if (snd->nsubstreams) {
	245	rc = virtsnd_pcm_build_devs(snd);
	246	if (rc)
	247	return rc;
	248	}
	249
19325fed AY	250	if (snd->nchmaps) {
	251	rc = virtsnd_chmap_build_devs(snd);
	252	if (rc)
	253	return rc;
	254	}
	255
de3a9980 AY	256	return snd_card_register(snd->card);
	257	}
	258
	259	/**
	260	* virtsnd_validate() - Validate if the device can be started.
	261	* @vdev: VirtIO parent device.
	262	*
	263	* Context: Any context.
	264	* Return: 0 on success, -EINVAL on failure.
	265	*/
	266	static int virtsnd_validate(struct virtio_device *vdev)
	267	{
	268	if (!vdev->config->get) {
	269	dev_err(&vdev->dev, "configuration access disabled\n");
	270	return -EINVAL;
	271	}
	272
	273	if (!virtio_has_feature(vdev, VIRTIO_F_VERSION_1)) {
	274	dev_err(&vdev->dev,
	275	"device does not comply with spec version 1.x\n");
	276	return -EINVAL;
	277	}
	278
9d45e514 AY	279	if (!virtsnd_msg_timeout_ms) {
	280	dev_err(&vdev->dev, "msg_timeout_ms value cannot be zero\n");
	281	return -EINVAL;
	282	}
	283
29b96bf5 AY	284	if (virtsnd_pcm_validate(vdev))
	285	return -EINVAL;
	286
de3a9980 AY	287	return 0;
	288	}
	289
	290	/**
	291	* virtsnd_probe() - Create and initialize the device.
	292	* @vdev: VirtIO parent device.
	293	*
	294	* Context: Any context that permits to sleep.
	295	* Return: 0 on success, -errno on failure.
	296	*/
	297	static int virtsnd_probe(struct virtio_device *vdev)
	298	{
	299	struct virtio_snd *snd;
	300	unsigned int i;
	301	int rc;
	302
	303	snd = devm_kzalloc(&vdev->dev, sizeof(*snd), GFP_KERNEL);
	304	if (!snd)
	305	return -ENOMEM;
	306
	307	snd->vdev = vdev;
9d45e514	308	INIT_LIST_HEAD(&snd->ctl_msgs);
29b96bf5	309	INIT_LIST_HEAD(&snd->pcm_list);
de3a9980 AY	310
	311	vdev->priv = snd;
	312
	313	for (i = 0; i < VIRTIO_SND_VQ_MAX; ++i)
	314	spin_lock_init(&snd->queues[i].lock);
	315
	316	rc = virtsnd_find_vqs(snd);
	317	if (rc)
	318	goto on_exit;
	319
	320	virtio_device_ready(vdev);
	321
	322	rc = virtsnd_build_devs(snd);
	323	if (rc)
	324	goto on_exit;
	325
	326	virtsnd_enable_event_vq(snd);
	327
	328	on_exit:
	329	if (rc)
	330	virtsnd_remove(vdev);
	331
	332	return rc;
	333	}
	334
	335	/**
	336	* virtsnd_remove() - Remove VirtIO and ALSA devices.
	337	* @vdev: VirtIO parent device.
	338	*
	339	* Context: Any context that permits to sleep.
	340	*/
	341	static void virtsnd_remove(struct virtio_device *vdev)
	342	{
	343	struct virtio_snd *snd = vdev->priv;
29b96bf5	344	unsigned int i;
de3a9980 AY	345
de3a9980 AY	346	virtsnd_disable_event_vq(snd);
9d45e514	347	virtsnd_ctl_msg_cancel_all(snd);
de3a9980 AY	348
	349	if (snd->card)
	350	snd_card_free(snd->card);
	351
	352	vdev->config->del_vqs(vdev);
d9679d00	353	virtio_reset_device(vdev);
de3a9980	354
f40a2867 AY	355	for (i = 0; snd->substreams && i < snd->nsubstreams; ++i) {
	356	struct virtio_pcm_substream *vss = &snd->substreams[i];
	357
	358	cancel_work_sync(&vss->elapsed_period);
	359	virtsnd_pcm_msg_free(vss);
	360	}
29b96bf5	361
de3a9980 AY	362	kfree(snd->event_msgs);
	363	}
	364
575483e9 AY	365	#ifdef CONFIG_PM_SLEEP
	366	/**
	367	* virtsnd_freeze() - Suspend device.
	368	* @vdev: VirtIO parent device.
	369	*
	370	* Context: Any context.
	371	* Return: 0 on success, -errno on failure.
	372	*/
	373	static int virtsnd_freeze(struct virtio_device *vdev)
	374	{
	375	struct virtio_snd *snd = vdev->priv;
	376	unsigned int i;
	377
	378	virtsnd_disable_event_vq(snd);
	379	virtsnd_ctl_msg_cancel_all(snd);
	380
	381	vdev->config->del_vqs(vdev);
d9679d00	382	virtio_reset_device(vdev);
575483e9 AY	383
	384	for (i = 0; i < snd->nsubstreams; ++i)
	385	cancel_work_sync(&snd->substreams[i].elapsed_period);
	386
	387	kfree(snd->event_msgs);
	388	snd->event_msgs = NULL;
	389
	390	return 0;
	391	}
	392
	393	/**
	394	* virtsnd_restore() - Resume device.
	395	* @vdev: VirtIO parent device.
	396	*
	397	* Context: Any context.
	398	* Return: 0 on success, -errno on failure.
	399	*/
	400	static int virtsnd_restore(struct virtio_device *vdev)
	401	{
	402	struct virtio_snd *snd = vdev->priv;
	403	int rc;
	404
	405	rc = virtsnd_find_vqs(snd);
	406	if (rc)
	407	return rc;
	408
	409	virtio_device_ready(vdev);
	410
	411	virtsnd_enable_event_vq(snd);
	412
	413	return 0;
	414	}
	415	#endif /* CONFIG_PM_SLEEP */
	416
de3a9980 AY	417	static const struct virtio_device_id id_table[] = {
	418	{ VIRTIO_ID_SOUND, VIRTIO_DEV_ANY_ID },
	419	{ 0 },
	420	};
	421
	422	static struct virtio_driver virtsnd_driver = {
	423	.driver.name = KBUILD_MODNAME,
	424	.driver.owner = THIS_MODULE,
	425	.id_table = id_table,
	426	.validate = virtsnd_validate,
	427	.probe = virtsnd_probe,
	428	.remove = virtsnd_remove,
575483e9 AY	429	#ifdef CONFIG_PM_SLEEP
	430	.freeze = virtsnd_freeze,
	431	.restore = virtsnd_restore,
	432	#endif
de3a9980 AY	433	};
de3a9980 AY	434
d91cbe83	435	module_virtio_driver(virtsnd_driver);
de3a9980 AY	436
	437	MODULE_DEVICE_TABLE(virtio, id_table);
	438	MODULE_DESCRIPTION("Virtio sound card driver");
	439	MODULE_LICENSE("GPL");