sound/xen/xen_snd_front.c

0001 // SPDX-License-Identifier: GPL-2.0 OR MIT
0002
0003 /*
0004  * Xen para-virtual sound device
0005  *
0006  * Copyright (C) 2016-2018 EPAM Systems Inc.
0007  *
0008  * Author: Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
0009  */
0010
0011 #include <linux/delay.h>
0012 #include <linux/module.h>
0013
0014 #include <xen/page.h>
0015 #include <xen/platform_pci.h>
0016 #include <xen/xen.h>
0017 #include <xen/xenbus.h>
0018
0019 #include <xen/xen-front-pgdir-shbuf.h>
0020 #include <xen/interface/io/sndif.h>
0021
0022 #include "xen_snd_front.h"
0023 #include "xen_snd_front_alsa.h"
0024 #include "xen_snd_front_evtchnl.h"
0025
0026 static struct xensnd_req *
0027 be_stream_prepare_req(struct xen_snd_front_evtchnl *evtchnl, u8 operation)
0028 {
0029     struct xensnd_req *req;
0030
0031     req = RING_GET_REQUEST(&evtchnl->u.req.ring,
0032                    evtchnl->u.req.ring.req_prod_pvt);
0033     req->operation = operation;
0034     req->id = evtchnl->evt_next_id++;
0035     evtchnl->evt_id = req->id;
0036     return req;
0037 }
0038
0039 static int be_stream_do_io(struct xen_snd_front_evtchnl *evtchnl)
0040 {
0041     if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED))
0042         return -EIO;
0043
0044     reinit_completion(&evtchnl->u.req.completion);
0045     xen_snd_front_evtchnl_flush(evtchnl);
0046     return 0;
0047 }
0048
0049 static int be_stream_wait_io(struct xen_snd_front_evtchnl *evtchnl)
0050 {
0051     if (wait_for_completion_timeout(&evtchnl->u.req.completion,
0052             msecs_to_jiffies(VSND_WAIT_BACK_MS)) <= 0)
0053         return -ETIMEDOUT;
0054
0055     return evtchnl->u.req.resp_status;
0056 }
0057
0058 int xen_snd_front_stream_query_hw_param(struct xen_snd_front_evtchnl *evtchnl,
0059                     struct xensnd_query_hw_param *hw_param_req,
0060                     struct xensnd_query_hw_param *hw_param_resp)
0061 {
0062     struct xensnd_req *req;
0063     int ret;
0064
0065     mutex_lock(&evtchnl->u.req.req_io_lock);
0066
0067     mutex_lock(&evtchnl->ring_io_lock);
0068     req = be_stream_prepare_req(evtchnl, XENSND_OP_HW_PARAM_QUERY);
0069     req->op.hw_param = *hw_param_req;
0070     mutex_unlock(&evtchnl->ring_io_lock);
0071
0072     ret = be_stream_do_io(evtchnl);
0073
0074     if (ret == 0)
0075         ret = be_stream_wait_io(evtchnl);
0076
0077     if (ret == 0)
0078         *hw_param_resp = evtchnl->u.req.resp.hw_param;
0079
0080     mutex_unlock(&evtchnl->u.req.req_io_lock);
0081     return ret;
0082 }
0083
0084 int xen_snd_front_stream_prepare(struct xen_snd_front_evtchnl *evtchnl,
0085                  struct xen_front_pgdir_shbuf *shbuf,
0086                  u8 format, unsigned int channels,
0087                  unsigned int rate, u32 buffer_sz,
0088                  u32 period_sz)
0089 {
0090     struct xensnd_req *req;
0091     int ret;
0092
0093     mutex_lock(&evtchnl->u.req.req_io_lock);
0094
0095     mutex_lock(&evtchnl->ring_io_lock);
0096     req = be_stream_prepare_req(evtchnl, XENSND_OP_OPEN);
0097     req->op.open.pcm_format = format;
0098     req->op.open.pcm_channels = channels;
0099     req->op.open.pcm_rate = rate;
0100     req->op.open.buffer_sz = buffer_sz;
0101     req->op.open.period_sz = period_sz;
0102     req->op.open.gref_directory =
0103         xen_front_pgdir_shbuf_get_dir_start(shbuf);
0104     mutex_unlock(&evtchnl->ring_io_lock);
0105
0106     ret = be_stream_do_io(evtchnl);
0107
0108     if (ret == 0)
0109         ret = be_stream_wait_io(evtchnl);
0110
0111     mutex_unlock(&evtchnl->u.req.req_io_lock);
0112     return ret;
0113 }
0114
0115 int xen_snd_front_stream_close(struct xen_snd_front_evtchnl *evtchnl)
0116 {
0117     __always_unused struct xensnd_req *req;
0118     int ret;
0119
0120     mutex_lock(&evtchnl->u.req.req_io_lock);
0121
0122     mutex_lock(&evtchnl->ring_io_lock);
0123     req = be_stream_prepare_req(evtchnl, XENSND_OP_CLOSE);
0124     mutex_unlock(&evtchnl->ring_io_lock);
0125
0126     ret = be_stream_do_io(evtchnl);
0127
0128     if (ret == 0)
0129         ret = be_stream_wait_io(evtchnl);
0130
0131     mutex_unlock(&evtchnl->u.req.req_io_lock);
0132     return ret;
0133 }
0134
0135 int xen_snd_front_stream_write(struct xen_snd_front_evtchnl *evtchnl,
0136                    unsigned long pos, unsigned long count)
0137 {
0138     struct xensnd_req *req;
0139     int ret;
0140
0141     mutex_lock(&evtchnl->u.req.req_io_lock);
0142
0143     mutex_lock(&evtchnl->ring_io_lock);
0144     req = be_stream_prepare_req(evtchnl, XENSND_OP_WRITE);
0145     req->op.rw.length = count;
0146     req->op.rw.offset = pos;
0147     mutex_unlock(&evtchnl->ring_io_lock);
0148
0149     ret = be_stream_do_io(evtchnl);
0150
0151     if (ret == 0)
0152         ret = be_stream_wait_io(evtchnl);
0153
0154     mutex_unlock(&evtchnl->u.req.req_io_lock);
0155     return ret;
0156 }
0157
0158 int xen_snd_front_stream_read(struct xen_snd_front_evtchnl *evtchnl,
0159                   unsigned long pos, unsigned long count)
0160 {
0161     struct xensnd_req *req;
0162     int ret;
0163
0164     mutex_lock(&evtchnl->u.req.req_io_lock);
0165
0166     mutex_lock(&evtchnl->ring_io_lock);
0167     req = be_stream_prepare_req(evtchnl, XENSND_OP_READ);
0168     req->op.rw.length = count;
0169     req->op.rw.offset = pos;
0170     mutex_unlock(&evtchnl->ring_io_lock);
0171
0172     ret = be_stream_do_io(evtchnl);
0173
0174     if (ret == 0)
0175         ret = be_stream_wait_io(evtchnl);
0176
0177     mutex_unlock(&evtchnl->u.req.req_io_lock);
0178     return ret;
0179 }
0180
0181 int xen_snd_front_stream_trigger(struct xen_snd_front_evtchnl *evtchnl,
0182                  int type)
0183 {
0184     struct xensnd_req *req;
0185     int ret;
0186
0187     mutex_lock(&evtchnl->u.req.req_io_lock);
0188
0189     mutex_lock(&evtchnl->ring_io_lock);
0190     req = be_stream_prepare_req(evtchnl, XENSND_OP_TRIGGER);
0191     req->op.trigger.type = type;
0192     mutex_unlock(&evtchnl->ring_io_lock);
0193
0194     ret = be_stream_do_io(evtchnl);
0195
0196     if (ret == 0)
0197         ret = be_stream_wait_io(evtchnl);
0198
0199     mutex_unlock(&evtchnl->u.req.req_io_lock);
0200     return ret;
0201 }
0202
0203 static void xen_snd_drv_fini(struct xen_snd_front_info *front_info)
0204 {
0205     xen_snd_front_alsa_fini(front_info);
0206     xen_snd_front_evtchnl_free_all(front_info);
0207 }
0208
0209 static int sndback_initwait(struct xen_snd_front_info *front_info)
0210 {
0211     int num_streams;
0212     int ret;
0213
0214     ret = xen_snd_front_cfg_card(front_info, &num_streams);
0215     if (ret < 0)
0216         return ret;
0217
0218     /* create event channels for all streams and publish */
0219     ret = xen_snd_front_evtchnl_create_all(front_info, num_streams);
0220     if (ret < 0)
0221         return ret;
0222
0223     return xen_snd_front_evtchnl_publish_all(front_info);
0224 }
0225
0226 static int sndback_connect(struct xen_snd_front_info *front_info)
0227 {
0228     return xen_snd_front_alsa_init(front_info);
0229 }
0230
0231 static void sndback_disconnect(struct xen_snd_front_info *front_info)
0232 {
0233     xen_snd_drv_fini(front_info);
0234     xenbus_switch_state(front_info->xb_dev, XenbusStateInitialising);
0235 }
0236
0237 static void sndback_changed(struct xenbus_device *xb_dev,
0238                 enum xenbus_state backend_state)
0239 {
0240     struct xen_snd_front_info *front_info = dev_get_drvdata(&xb_dev->dev);
0241     int ret;
0242
0243     dev_dbg(&xb_dev->dev, "Backend state is %s, front is %s\n",
0244         xenbus_strstate(backend_state),
0245         xenbus_strstate(xb_dev->state));
0246
0247     switch (backend_state) {
0248     case XenbusStateReconfiguring:
0249     case XenbusStateReconfigured:
0250     case XenbusStateInitialised:
0251         break;
0252
0253     case XenbusStateInitialising:
0254         /* Recovering after backend unexpected closure. */
0255         sndback_disconnect(front_info);
0256         break;
0257
0258     case XenbusStateInitWait:
0259         /* Recovering after backend unexpected closure. */
0260         sndback_disconnect(front_info);
0261
0262         ret = sndback_initwait(front_info);
0263         if (ret < 0)
0264             xenbus_dev_fatal(xb_dev, ret, "initializing frontend");
0265         else
0266             xenbus_switch_state(xb_dev, XenbusStateInitialised);
0267         break;
0268
0269     case XenbusStateConnected:
0270         if (xb_dev->state != XenbusStateInitialised)
0271             break;
0272
0273         ret = sndback_connect(front_info);
0274         if (ret < 0)
0275             xenbus_dev_fatal(xb_dev, ret, "initializing frontend");
0276         else
0277             xenbus_switch_state(xb_dev, XenbusStateConnected);
0278         break;
0279
0280     case XenbusStateClosing:
0281         /*
0282          * In this state backend starts freeing resources,
0283          * so let it go into closed state first, so we can also
0284          * remove ours.
0285          */
0286         break;
0287
0288     case XenbusStateUnknown:
0289     case XenbusStateClosed:
0290         if (xb_dev->state == XenbusStateClosed)
0291             break;
0292
0293         sndback_disconnect(front_info);
0294         break;
0295     }
0296 }
0297
0298 static int xen_drv_probe(struct xenbus_device *xb_dev,
0299              const struct xenbus_device_id *id)
0300 {
0301     struct xen_snd_front_info *front_info;
0302
0303     front_info = devm_kzalloc(&xb_dev->dev,
0304                   sizeof(*front_info), GFP_KERNEL);
0305     if (!front_info)
0306         return -ENOMEM;
0307
0308     front_info->xb_dev = xb_dev;
0309     dev_set_drvdata(&xb_dev->dev, front_info);
0310
0311     return xenbus_switch_state(xb_dev, XenbusStateInitialising);
0312 }
0313
0314 static int xen_drv_remove(struct xenbus_device *dev)
0315 {
0316     struct xen_snd_front_info *front_info = dev_get_drvdata(&dev->dev);
0317     int to = 100;
0318
0319     xenbus_switch_state(dev, XenbusStateClosing);
0320
0321     /*
0322      * On driver removal it is disconnected from XenBus,
0323      * so no backend state change events come via .otherend_changed
0324      * callback. This prevents us from exiting gracefully, e.g.
0325      * signaling the backend to free event channels, waiting for its
0326      * state to change to XenbusStateClosed and cleaning at our end.
0327      * Normally when front driver removed backend will finally go into
0328      * XenbusStateInitWait state.
0329      *
0330      * Workaround: read backend's state manually and wait with time-out.
0331      */
0332     while ((xenbus_read_unsigned(front_info->xb_dev->otherend, "state",
0333                      XenbusStateUnknown) != XenbusStateInitWait) &&
0334            --to)
0335         msleep(10);
0336
0337     if (!to) {
0338         unsigned int state;
0339
0340         state = xenbus_read_unsigned(front_info->xb_dev->otherend,
0341                          "state", XenbusStateUnknown);
0342         pr_err("Backend state is %s while removing driver\n",
0343                xenbus_strstate(state));
0344     }
0345
0346     xen_snd_drv_fini(front_info);
0347     xenbus_frontend_closed(dev);
0348     return 0;
0349 }
0350
0351 static const struct xenbus_device_id xen_drv_ids[] = {
0352     { XENSND_DRIVER_NAME },
0353     { "" }
0354 };
0355
0356 static struct xenbus_driver xen_driver = {
0357     .ids = xen_drv_ids,
0358     .probe = xen_drv_probe,
0359     .remove = xen_drv_remove,
0360     .otherend_changed = sndback_changed,
0361     .not_essential = true,
0362 };
0363
0364 static int __init xen_drv_init(void)
0365 {
0366     if (!xen_domain())
0367         return -ENODEV;
0368
0369     if (!xen_has_pv_devices())
0370         return -ENODEV;
0371
0372     /* At the moment we only support case with XEN_PAGE_SIZE == PAGE_SIZE */
0373     if (XEN_PAGE_SIZE != PAGE_SIZE) {
0374         pr_err(XENSND_DRIVER_NAME ": different kernel and Xen page sizes are not supported: XEN_PAGE_SIZE (%lu) != PAGE_SIZE (%lu)\n",
0375                XEN_PAGE_SIZE, PAGE_SIZE);
0376         return -ENODEV;
0377     }
0378
0379     pr_info("Initialising Xen " XENSND_DRIVER_NAME " frontend driver\n");
0380     return xenbus_register_frontend(&xen_driver);
0381 }
0382
0383 static void __exit xen_drv_fini(void)
0384 {
0385     pr_info("Unregistering Xen " XENSND_DRIVER_NAME " frontend driver\n");
0386     xenbus_unregister_driver(&xen_driver);
0387 }
0388
0389 module_init(xen_drv_init);
0390 module_exit(xen_drv_fini);
0391
0392 MODULE_DESCRIPTION("Xen virtual sound device frontend");
0393 MODULE_LICENSE("GPL");
0394 MODULE_ALIAS("xen:" XENSND_DRIVER_NAME);