sound/xen/xen_snd_front.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0 OR MIT

 /*
  * Xen para-virtual sound device
  *
  * Copyright (C) 2016-2018 EPAM Systems Inc.
  *
  * Author: Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
  */

 #include <linux/delay.h>
 #include <linux/module.h>

 #include <xen/page.h>
 #include <xen/platform_pci.h>
 #include <xen/xen.h>
 #include <xen/xenbus.h>

 #include <xen/xen-front-pgdir-shbuf.h>
 #include <xen/interface/io/sndif.h>

 #include "xen_snd_front.h"
 #include "xen_snd_front_alsa.h"
 #include "xen_snd_front_evtchnl.h"

 static struct xensnd_req *
 be_stream_prepare_req(struct xen_snd_front_evtchnl *evtchnl, u8 operation)
 {
 	struct xensnd_req *req;

 	req = RING_GET_REQUEST(&evtchnl->u.req.ring,
 			       evtchnl->u.req.ring.req_prod_pvt);
 	req->operation = operation;
 	req->id = evtchnl->evt_next_id++;
 	evtchnl->evt_id = req->id;
 	return req;
 }

 static int be_stream_do_io(struct xen_snd_front_evtchnl *evtchnl)
 {
 	if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED))
 		return -EIO;

 	reinit_completion(&evtchnl->u.req.completion);
 	xen_snd_front_evtchnl_flush(evtchnl);
 	return 0;
 }

 static int be_stream_wait_io(struct xen_snd_front_evtchnl *evtchnl)
 {
 	if (wait_for_completion_timeout(&evtchnl->u.req.completion,
 			msecs_to_jiffies(VSND_WAIT_BACK_MS)) <= 0)
 		return -ETIMEDOUT;

 	return evtchnl->u.req.resp_status;
 }

 int xen_snd_front_stream_query_hw_param(struct xen_snd_front_evtchnl *evtchnl,
 					struct xensnd_query_hw_param *hw_param_req,
 					struct xensnd_query_hw_param *hw_param_resp)
 {
 	struct xensnd_req *req;
 	int ret;

 	mutex_lock(&evtchnl->u.req.req_io_lock);

 	mutex_lock(&evtchnl->ring_io_lock);
 	req = be_stream_prepare_req(evtchnl, XENSND_OP_HW_PARAM_QUERY);
 	req->op.hw_param = *hw_param_req;
 	mutex_unlock(&evtchnl->ring_io_lock);

 	ret = be_stream_do_io(evtchnl);

 	if (ret == 0)
 		ret = be_stream_wait_io(evtchnl);

 	if (ret == 0)
 		*hw_param_resp = evtchnl->u.req.resp.hw_param;

 	mutex_unlock(&evtchnl->u.req.req_io_lock);
 	return ret;
 }

 int xen_snd_front_stream_prepare(struct xen_snd_front_evtchnl *evtchnl,
 				 struct xen_front_pgdir_shbuf *shbuf,
 				 u8 format, unsigned int channels,
 				 unsigned int rate, u32 buffer_sz,
 				 u32 period_sz)
 {
 	struct xensnd_req *req;
 	int ret;

 	mutex_lock(&evtchnl->u.req.req_io_lock);

 	mutex_lock(&evtchnl->ring_io_lock);
 	req = be_stream_prepare_req(evtchnl, XENSND_OP_OPEN);
 	req->op.open.pcm_format = format;
 	req->op.open.pcm_channels = channels;
 	req->op.open.pcm_rate = rate;
 	req->op.open.buffer_sz = buffer_sz;
 	req->op.open.period_sz = period_sz;
 	req->op.open.gref_directory =
 		xen_front_pgdir_shbuf_get_dir_start(shbuf);
 	mutex_unlock(&evtchnl->ring_io_lock);

 	ret = be_stream_do_io(evtchnl);

 	if (ret == 0)
 		ret = be_stream_wait_io(evtchnl);

 	mutex_unlock(&evtchnl->u.req.req_io_lock);
 	return ret;
 }

 int xen_snd_front_stream_close(struct xen_snd_front_evtchnl *evtchnl)
 {
 	__always_unused struct xensnd_req *req;
 	int ret;

 	mutex_lock(&evtchnl->u.req.req_io_lock);

 	mutex_lock(&evtchnl->ring_io_lock);
 	req = be_stream_prepare_req(evtchnl, XENSND_OP_CLOSE);
 	mutex_unlock(&evtchnl->ring_io_lock);

 	ret = be_stream_do_io(evtchnl);

 	if (ret == 0)
 		ret = be_stream_wait_io(evtchnl);

 	mutex_unlock(&evtchnl->u.req.req_io_lock);
 	return ret;
 }

 int xen_snd_front_stream_write(struct xen_snd_front_evtchnl *evtchnl,
 			       unsigned long pos, unsigned long count)
 {
 	struct xensnd_req *req;
 	int ret;

 	mutex_lock(&evtchnl->u.req.req_io_lock);

 	mutex_lock(&evtchnl->ring_io_lock);
 	req = be_stream_prepare_req(evtchnl, XENSND_OP_WRITE);
 	req->op.rw.length = count;
 	req->op.rw.offset = pos;
 	mutex_unlock(&evtchnl->ring_io_lock);

 	ret = be_stream_do_io(evtchnl);

 	if (ret == 0)
 		ret = be_stream_wait_io(evtchnl);

 	mutex_unlock(&evtchnl->u.req.req_io_lock);
 	return ret;
 }

 int xen_snd_front_stream_read(struct xen_snd_front_evtchnl *evtchnl,
 			      unsigned long pos, unsigned long count)
 {
 	struct xensnd_req *req;
 	int ret;

 	mutex_lock(&evtchnl->u.req.req_io_lock);

 	mutex_lock(&evtchnl->ring_io_lock);
 	req = be_stream_prepare_req(evtchnl, XENSND_OP_READ);
 	req->op.rw.length = count;
 	req->op.rw.offset = pos;
 	mutex_unlock(&evtchnl->ring_io_lock);

 	ret = be_stream_do_io(evtchnl);

 	if (ret == 0)
 		ret = be_stream_wait_io(evtchnl);

 	mutex_unlock(&evtchnl->u.req.req_io_lock);
 	return ret;
 }

 int xen_snd_front_stream_trigger(struct xen_snd_front_evtchnl *evtchnl,
 				 int type)
 {
 	struct xensnd_req *req;
 	int ret;

 	mutex_lock(&evtchnl->u.req.req_io_lock);

 	mutex_lock(&evtchnl->ring_io_lock);
 	req = be_stream_prepare_req(evtchnl, XENSND_OP_TRIGGER);
 	req->op.trigger.type = type;
 	mutex_unlock(&evtchnl->ring_io_lock);

 	ret = be_stream_do_io(evtchnl);

 	if (ret == 0)
 		ret = be_stream_wait_io(evtchnl);

 	mutex_unlock(&evtchnl->u.req.req_io_lock);
 	return ret;
 }

 static void xen_snd_drv_fini(struct xen_snd_front_info *front_info)
 {
 	xen_snd_front_alsa_fini(front_info);
 	xen_snd_front_evtchnl_free_all(front_info);
 }

 static int sndback_initwait(struct xen_snd_front_info *front_info)
 {
 	int num_streams;
 	int ret;

 	ret = xen_snd_front_cfg_card(front_info, &num_streams);
 	if (ret < 0)
 		return ret;

 	/* create event channels for all streams and publish */
 	ret = xen_snd_front_evtchnl_create_all(front_info, num_streams);
 	if (ret < 0)
 		return ret;

 	return xen_snd_front_evtchnl_publish_all(front_info);
 }

 static int sndback_connect(struct xen_snd_front_info *front_info)
 {
 	return xen_snd_front_alsa_init(front_info);
 }

 static void sndback_disconnect(struct xen_snd_front_info *front_info)
 {
 	xen_snd_drv_fini(front_info);
 	xenbus_switch_state(front_info->xb_dev, XenbusStateInitialising);
 }

 static void sndback_changed(struct xenbus_device *xb_dev,
 			    enum xenbus_state backend_state)
 {
 	struct xen_snd_front_info *front_info = dev_get_drvdata(&xb_dev->dev);
 	int ret;

 	dev_dbg(&xb_dev->dev, "Backend state is %s, front is %s\n",
 		xenbus_strstate(backend_state),
 		xenbus_strstate(xb_dev->state));

 	switch (backend_state) {
 	case XenbusStateReconfiguring:
 	case XenbusStateReconfigured:
 	case XenbusStateInitialised:
 		break;

 	case XenbusStateInitialising:
 		/* Recovering after backend unexpected closure. */
 		sndback_disconnect(front_info);
 		break;

 	case XenbusStateInitWait:
 		/* Recovering after backend unexpected closure. */
 		sndback_disconnect(front_info);

 		ret = sndback_initwait(front_info);
 		if (ret < 0)
 			xenbus_dev_fatal(xb_dev, ret, "initializing frontend");
 		else
 			xenbus_switch_state(xb_dev, XenbusStateInitialised);
 		break;

 	case XenbusStateConnected:
 		if (xb_dev->state != XenbusStateInitialised)
 			break;

 		ret = sndback_connect(front_info);
 		if (ret < 0)
 			xenbus_dev_fatal(xb_dev, ret, "initializing frontend");
 		else
 			xenbus_switch_state(xb_dev, XenbusStateConnected);
 		break;

 	case XenbusStateClosing:
 		/*
 		 * In this state backend starts freeing resources,
 		 * so let it go into closed state first, so we can also
 		 * remove ours.
 		 */
 		break;

 	case XenbusStateUnknown:
 	case XenbusStateClosed:
 		if (xb_dev->state == XenbusStateClosed)
 			break;

 		sndback_disconnect(front_info);
 		break;
 	}
 }

 static int xen_drv_probe(struct xenbus_device *xb_dev,
 			 const struct xenbus_device_id *id)
 {
 	struct xen_snd_front_info *front_info;

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

 	front_info->xb_dev = xb_dev;
 	dev_set_drvdata(&xb_dev->dev, front_info);

 	return xenbus_switch_state(xb_dev, XenbusStateInitialising);
 }

 static void xen_drv_remove(struct xenbus_device *dev)
 {
 	struct xen_snd_front_info *front_info = dev_get_drvdata(&dev->dev);
 	int to = 100;

 	xenbus_switch_state(dev, XenbusStateClosing);

 	/*
 	 * On driver removal it is disconnected from XenBus,
 	 * so no backend state change events come via .otherend_changed
 	 * callback. This prevents us from exiting gracefully, e.g.
 	 * signaling the backend to free event channels, waiting for its
 	 * state to change to XenbusStateClosed and cleaning at our end.
 	 * Normally when front driver removed backend will finally go into
 	 * XenbusStateInitWait state.
 	 *
 	 * Workaround: read backend's state manually and wait with time-out.
 	 */
 	while ((xenbus_read_unsigned(front_info->xb_dev->otherend, "state",
 				     XenbusStateUnknown) != XenbusStateInitWait) &&
 	       --to)
 		msleep(10);

 	if (!to) {
 		unsigned int state;

 		state = xenbus_read_unsigned(front_info->xb_dev->otherend,
 					     "state", XenbusStateUnknown);
 		pr_err("Backend state is %s while removing driver\n",
 		       xenbus_strstate(state));
 	}

 	xen_snd_drv_fini(front_info);
 	xenbus_frontend_closed(dev);
 }

 static const struct xenbus_device_id xen_drv_ids[] = {
 	{ XENSND_DRIVER_NAME },
 	{ "" }
 };

 static struct xenbus_driver xen_driver = {
 	.ids = xen_drv_ids,
 	.probe = xen_drv_probe,
 	.remove = xen_drv_remove,
 	.otherend_changed = sndback_changed,
 	.not_essential = true,
 };

 static int __init xen_drv_init(void)
 {
 	if (!xen_domain())
 		return -ENODEV;

 	if (!xen_has_pv_devices())
 		return -ENODEV;

 	/* At the moment we only support case with XEN_PAGE_SIZE == PAGE_SIZE */
 	if (XEN_PAGE_SIZE != PAGE_SIZE) {
 		pr_err(XENSND_DRIVER_NAME ": different kernel and Xen page sizes are not supported: XEN_PAGE_SIZE (%lu) != PAGE_SIZE (%lu)\n",
 		       XEN_PAGE_SIZE, PAGE_SIZE);
 		return -ENODEV;
 	}

 	pr_info("Initialising Xen " XENSND_DRIVER_NAME " frontend driver\n");
 	return xenbus_register_frontend(&xen_driver);
 }

 static void __exit xen_drv_fini(void)
 {
 	pr_info("Unregistering Xen " XENSND_DRIVER_NAME " frontend driver\n");
 	xenbus_unregister_driver(&xen_driver);
 }

 module_init(xen_drv_init);
 module_exit(xen_drv_fini);

 MODULE_DESCRIPTION("Xen virtual sound device frontend");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("xen:" XENSND_DRIVER_NAME);
	// SPDX-License-Identifier: GPL-2.0 OR MIT

	/*
	* Xen para-virtual sound device
	*
	* Copyright (C) 2016-2018 EPAM Systems Inc.
	*
	* Author: Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
	*/

	#include <linux/delay.h>
	#include <linux/module.h>

	#include <xen/page.h>
	#include <xen/platform_pci.h>
	#include <xen/xen.h>
	#include <xen/xenbus.h>

	#include <xen/xen-front-pgdir-shbuf.h>
	#include <xen/interface/io/sndif.h>

	#include "xen_snd_front.h"
	#include "xen_snd_front_alsa.h"
	#include "xen_snd_front_evtchnl.h"

	static struct xensnd_req *
	be_stream_prepare_req(struct xen_snd_front_evtchnl *evtchnl, u8 operation)
	{
	struct xensnd_req *req;

	req = RING_GET_REQUEST(&evtchnl->u.req.ring,
	evtchnl->u.req.ring.req_prod_pvt);
	req->operation = operation;
	req->id = evtchnl->evt_next_id++;
	evtchnl->evt_id = req->id;
	return req;
	}

	static int be_stream_do_io(struct xen_snd_front_evtchnl *evtchnl)
	{
	if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED))
	return -EIO;

	reinit_completion(&evtchnl->u.req.completion);
	xen_snd_front_evtchnl_flush(evtchnl);
	return 0;
	}

	static int be_stream_wait_io(struct xen_snd_front_evtchnl *evtchnl)
	{
	if (wait_for_completion_timeout(&evtchnl->u.req.completion,
	msecs_to_jiffies(VSND_WAIT_BACK_MS)) <= 0)
	return -ETIMEDOUT;

	return evtchnl->u.req.resp_status;
	}

	int xen_snd_front_stream_query_hw_param(struct xen_snd_front_evtchnl *evtchnl,
	struct xensnd_query_hw_param *hw_param_req,
	struct xensnd_query_hw_param *hw_param_resp)
	{
	struct xensnd_req *req;
	int ret;

	mutex_lock(&evtchnl->u.req.req_io_lock);

	mutex_lock(&evtchnl->ring_io_lock);
	req = be_stream_prepare_req(evtchnl, XENSND_OP_HW_PARAM_QUERY);
	req->op.hw_param = *hw_param_req;
	mutex_unlock(&evtchnl->ring_io_lock);

	ret = be_stream_do_io(evtchnl);

	if (ret == 0)
	ret = be_stream_wait_io(evtchnl);

	if (ret == 0)
	*hw_param_resp = evtchnl->u.req.resp.hw_param;

	mutex_unlock(&evtchnl->u.req.req_io_lock);
	return ret;
	}

	int xen_snd_front_stream_prepare(struct xen_snd_front_evtchnl *evtchnl,
	struct xen_front_pgdir_shbuf *shbuf,
	u8 format, unsigned int channels,
	unsigned int rate, u32 buffer_sz,
	u32 period_sz)
	{
	struct xensnd_req *req;
	int ret;

	mutex_lock(&evtchnl->u.req.req_io_lock);

	mutex_lock(&evtchnl->ring_io_lock);
	req = be_stream_prepare_req(evtchnl, XENSND_OP_OPEN);
	req->op.open.pcm_format = format;
	req->op.open.pcm_channels = channels;
	req->op.open.pcm_rate = rate;
	req->op.open.buffer_sz = buffer_sz;
	req->op.open.period_sz = period_sz;
	req->op.open.gref_directory =
	xen_front_pgdir_shbuf_get_dir_start(shbuf);
	mutex_unlock(&evtchnl->ring_io_lock);

	ret = be_stream_do_io(evtchnl);

	if (ret == 0)
	ret = be_stream_wait_io(evtchnl);

	mutex_unlock(&evtchnl->u.req.req_io_lock);
	return ret;
	}

	int xen_snd_front_stream_close(struct xen_snd_front_evtchnl *evtchnl)
	{
	__always_unused struct xensnd_req *req;
	int ret;

	mutex_lock(&evtchnl->u.req.req_io_lock);

	mutex_lock(&evtchnl->ring_io_lock);
	req = be_stream_prepare_req(evtchnl, XENSND_OP_CLOSE);
	mutex_unlock(&evtchnl->ring_io_lock);

	ret = be_stream_do_io(evtchnl);

	if (ret == 0)
	ret = be_stream_wait_io(evtchnl);

	mutex_unlock(&evtchnl->u.req.req_io_lock);
	return ret;
	}

	int xen_snd_front_stream_write(struct xen_snd_front_evtchnl *evtchnl,
	unsigned long pos, unsigned long count)
	{
	struct xensnd_req *req;
	int ret;

	mutex_lock(&evtchnl->u.req.req_io_lock);

	mutex_lock(&evtchnl->ring_io_lock);
	req = be_stream_prepare_req(evtchnl, XENSND_OP_WRITE);
	req->op.rw.length = count;
	req->op.rw.offset = pos;
	mutex_unlock(&evtchnl->ring_io_lock);

	ret = be_stream_do_io(evtchnl);

	if (ret == 0)
	ret = be_stream_wait_io(evtchnl);

	mutex_unlock(&evtchnl->u.req.req_io_lock);
	return ret;
	}

	int xen_snd_front_stream_read(struct xen_snd_front_evtchnl *evtchnl,
	unsigned long pos, unsigned long count)
	{
	struct xensnd_req *req;
	int ret;

	mutex_lock(&evtchnl->u.req.req_io_lock);

	mutex_lock(&evtchnl->ring_io_lock);
	req = be_stream_prepare_req(evtchnl, XENSND_OP_READ);
	req->op.rw.length = count;
	req->op.rw.offset = pos;
	mutex_unlock(&evtchnl->ring_io_lock);

	ret = be_stream_do_io(evtchnl);

	if (ret == 0)
	ret = be_stream_wait_io(evtchnl);

	mutex_unlock(&evtchnl->u.req.req_io_lock);
	return ret;
	}

	int xen_snd_front_stream_trigger(struct xen_snd_front_evtchnl *evtchnl,
	int type)
	{
	struct xensnd_req *req;
	int ret;

	mutex_lock(&evtchnl->u.req.req_io_lock);

	mutex_lock(&evtchnl->ring_io_lock);
	req = be_stream_prepare_req(evtchnl, XENSND_OP_TRIGGER);
	req->op.trigger.type = type;
	mutex_unlock(&evtchnl->ring_io_lock);

	ret = be_stream_do_io(evtchnl);

	if (ret == 0)
	ret = be_stream_wait_io(evtchnl);

	mutex_unlock(&evtchnl->u.req.req_io_lock);
	return ret;
	}

	static void xen_snd_drv_fini(struct xen_snd_front_info *front_info)
	{
	xen_snd_front_alsa_fini(front_info);
	xen_snd_front_evtchnl_free_all(front_info);
	}

	static int sndback_initwait(struct xen_snd_front_info *front_info)
	{
	int num_streams;
	int ret;

	ret = xen_snd_front_cfg_card(front_info, &num_streams);
	if (ret < 0)
	return ret;

	/* create event channels for all streams and publish */
	ret = xen_snd_front_evtchnl_create_all(front_info, num_streams);
	if (ret < 0)
	return ret;

	return xen_snd_front_evtchnl_publish_all(front_info);
	}

	static int sndback_connect(struct xen_snd_front_info *front_info)
	{
	return xen_snd_front_alsa_init(front_info);
	}

	static void sndback_disconnect(struct xen_snd_front_info *front_info)
	{
	xen_snd_drv_fini(front_info);
	xenbus_switch_state(front_info->xb_dev, XenbusStateInitialising);
	}

	static void sndback_changed(struct xenbus_device *xb_dev,
	enum xenbus_state backend_state)
	{
	struct xen_snd_front_info *front_info = dev_get_drvdata(&xb_dev->dev);
	int ret;

	dev_dbg(&xb_dev->dev, "Backend state is %s, front is %s\n",
	xenbus_strstate(backend_state),
	xenbus_strstate(xb_dev->state));

	switch (backend_state) {
	case XenbusStateReconfiguring:
	case XenbusStateReconfigured:
	case XenbusStateInitialised:
	break;

	case XenbusStateInitialising:
	/* Recovering after backend unexpected closure. */
	sndback_disconnect(front_info);
	break;

	case XenbusStateInitWait:
	/* Recovering after backend unexpected closure. */
	sndback_disconnect(front_info);

	ret = sndback_initwait(front_info);
	if (ret < 0)
	xenbus_dev_fatal(xb_dev, ret, "initializing frontend");
	else
	xenbus_switch_state(xb_dev, XenbusStateInitialised);
	break;

	case XenbusStateConnected:
	if (xb_dev->state != XenbusStateInitialised)
	break;

	ret = sndback_connect(front_info);
	if (ret < 0)
	xenbus_dev_fatal(xb_dev, ret, "initializing frontend");
	else
	xenbus_switch_state(xb_dev, XenbusStateConnected);
	break;

	case XenbusStateClosing:
	/*
	* In this state backend starts freeing resources,
	* so let it go into closed state first, so we can also
	* remove ours.
	*/
	break;

	case XenbusStateUnknown:
	case XenbusStateClosed:
	if (xb_dev->state == XenbusStateClosed)
	break;

	sndback_disconnect(front_info);
	break;
	}
	}

	static int xen_drv_probe(struct xenbus_device *xb_dev,
	const struct xenbus_device_id *id)
	{
	struct xen_snd_front_info *front_info;

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

	front_info->xb_dev = xb_dev;
	dev_set_drvdata(&xb_dev->dev, front_info);

	return xenbus_switch_state(xb_dev, XenbusStateInitialising);
	}

	static void xen_drv_remove(struct xenbus_device *dev)
	{
	struct xen_snd_front_info *front_info = dev_get_drvdata(&dev->dev);
	int to = 100;

	xenbus_switch_state(dev, XenbusStateClosing);

	/*
	* On driver removal it is disconnected from XenBus,
	* so no backend state change events come via .otherend_changed
	* callback. This prevents us from exiting gracefully, e.g.
	* signaling the backend to free event channels, waiting for its
	* state to change to XenbusStateClosed and cleaning at our end.
	* Normally when front driver removed backend will finally go into
	* XenbusStateInitWait state.
	*
	* Workaround: read backend's state manually and wait with time-out.
	*/
	while ((xenbus_read_unsigned(front_info->xb_dev->otherend, "state",
	XenbusStateUnknown) != XenbusStateInitWait) &&
	--to)
	msleep(10);

	if (!to) {
	unsigned int state;

	state = xenbus_read_unsigned(front_info->xb_dev->otherend,
	"state", XenbusStateUnknown);
	pr_err("Backend state is %s while removing driver\n",
	xenbus_strstate(state));
	}

	xen_snd_drv_fini(front_info);
	xenbus_frontend_closed(dev);
	}

	static const struct xenbus_device_id xen_drv_ids[] = {
	{ XENSND_DRIVER_NAME },
	{ "" }
	};

	static struct xenbus_driver xen_driver = {
	.ids = xen_drv_ids,
	.probe = xen_drv_probe,
	.remove = xen_drv_remove,
	.otherend_changed = sndback_changed,
	.not_essential = true,
	};

	static int __init xen_drv_init(void)
	{
	if (!xen_domain())
	return -ENODEV;

	if (!xen_has_pv_devices())
	return -ENODEV;

	/* At the moment we only support case with XEN_PAGE_SIZE == PAGE_SIZE */
	if (XEN_PAGE_SIZE != PAGE_SIZE) {
	pr_err(XENSND_DRIVER_NAME ": different kernel and Xen page sizes are not supported: XEN_PAGE_SIZE (%lu) != PAGE_SIZE (%lu)\n",
	XEN_PAGE_SIZE, PAGE_SIZE);
	return -ENODEV;
	}

	pr_info("Initialising Xen " XENSND_DRIVER_NAME " frontend driver\n");
	return xenbus_register_frontend(&xen_driver);
	}

	static void __exit xen_drv_fini(void)
	{
	pr_info("Unregistering Xen " XENSND_DRIVER_NAME " frontend driver\n");
	xenbus_unregister_driver(&xen_driver);
	}

	module_init(xen_drv_init);
	module_exit(xen_drv_fini);

	MODULE_DESCRIPTION("Xen virtual sound device frontend");
	MODULE_LICENSE("GPL");
	MODULE_ALIAS("xen:" XENSND_DRIVER_NAME);