mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 09:19:51 +00:00
![Dawei Li](/assets/img/avatar_default.png)
Since commit fc7a6209d5
("bus: Make remove callback return void")
forces bus_type::remove be void-returned, it doesn't make much sense for
any bus based driver implementing remove callbalk to return non-void to
its caller.
This change is for xen bus based drivers.
Acked-by: Juergen Gross <jgross@suse.com>
Signed-off-by: Dawei Li <set_pte_at@outlook.com>
Link: https://lore.kernel.org/r/TYCP286MB23238119AB4DF190997075C9CAE39@TYCP286MB2323.JPNP286.PROD.OUTLOOK.COM
Signed-off-by: Juergen Gross <jgross@suse.com>
393 lines
9.6 KiB
C
393 lines
9.6 KiB
C
// 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);
|