sound/xen/xen_snd_front.c

   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 <oleksandr_andrushchenko@epam.com>
   9  */
  10
  11 #include <linux/delay.h>
  12 #include <linux/module.h>
  13
  14 #include <xen/page.h>
  15 #include <xen/platform_pci.h>
  16 #include <xen/xen.h>
  17 #include <xen/xenbus.h>
  18
  19 #include <xen/interface/io/sndif.h>
  20
  21 #include "xen_snd_front.h"
  22 #include "xen_snd_front_alsa.h"
  23 #include "xen_snd_front_evtchnl.h"
  24 #include "xen_snd_front_shbuf.h"
  25
  26 static struct xensnd_req *
  27 be_stream_prepare_req(struct xen_snd_front_evtchnl *evtchnl, u8 operation)
  28 {
  29         struct xensnd_req *req;
  30
  31         req = RING_GET_REQUEST(&evtchnl->u.req.ring,
  32                                evtchnl->u.req.ring.req_prod_pvt);
  33         req->operation = operation;
  34         req->id = evtchnl->evt_next_id++;
  35         evtchnl->evt_id = req->id;
  36         return req;
  37 }
  38
  39 static int be_stream_do_io(struct xen_snd_front_evtchnl *evtchnl)
  40 {
  41         if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED))
  42                 return -EIO;
  43
  44         reinit_completion(&evtchnl->u.req.completion);
  45         xen_snd_front_evtchnl_flush(evtchnl);
  46         return 0;
  47 }
  48
  49 static int be_stream_wait_io(struct xen_snd_front_evtchnl *evtchnl)
  50 {
  51         if (wait_for_completion_timeout(&evtchnl->u.req.completion,
  52                         msecs_to_jiffies(VSND_WAIT_BACK_MS)) <= 0)
  53                 return -ETIMEDOUT;
  54
  55         return evtchnl->u.req.resp_status;
  56 }
  57
  58 int xen_snd_front_stream_query_hw_param(struct xen_snd_front_evtchnl *evtchnl,
  59                                         struct xensnd_query_hw_param *hw_param_req,
  60                                         struct xensnd_query_hw_param *hw_param_resp)
  61 {
  62         struct xensnd_req *req;
  63         int ret;
  64
  65         mutex_lock(&evtchnl->u.req.req_io_lock);
  66
  67         mutex_lock(&evtchnl->ring_io_lock);
  68         req = be_stream_prepare_req(evtchnl, XENSND_OP_HW_PARAM_QUERY);
  69         req->op.hw_param = *hw_param_req;
  70         mutex_unlock(&evtchnl->ring_io_lock);
  71
  72         ret = be_stream_do_io(evtchnl);
  73
  74         if (ret == 0)
  75                 ret = be_stream_wait_io(evtchnl);
  76
  77         if (ret == 0)
  78                 *hw_param_resp = evtchnl->u.req.resp.hw_param;
  79
  80         mutex_unlock(&evtchnl->u.req.req_io_lock);
  81         return ret;
  82 }
  83
  84 int xen_snd_front_stream_prepare(struct xen_snd_front_evtchnl *evtchnl,
  85                                  struct xen_snd_front_shbuf *sh_buf,
  86                                  u8 format, unsigned int channels,
  87                                  unsigned int rate, u32 buffer_sz,
  88                                  u32 period_sz)
  89 {
  90         struct xensnd_req *req;
  91         int ret;
  92
  93         mutex_lock(&evtchnl->u.req.req_io_lock);
  94
  95         mutex_lock(&evtchnl->ring_io_lock);
  96         req = be_stream_prepare_req(evtchnl, XENSND_OP_OPEN);
  97         req->op.open.pcm_format = format;
  98         req->op.open.pcm_channels = channels;
  99         req->op.open.pcm_rate = rate;
 100         req->op.open.buffer_sz = buffer_sz;
 101         req->op.open.period_sz = period_sz;
 102         req->op.open.gref_directory = xen_snd_front_shbuf_get_dir_start(sh_buf);
 103         mutex_unlock(&evtchnl->ring_io_lock);
 104
 105         ret = be_stream_do_io(evtchnl);
 106
 107         if (ret == 0)
 108                 ret = be_stream_wait_io(evtchnl);
 109
 110         mutex_unlock(&evtchnl->u.req.req_io_lock);
 111         return ret;
 112 }
 113
 114 int xen_snd_front_stream_close(struct xen_snd_front_evtchnl *evtchnl)
 115 {
 116         struct xensnd_req *req;
 117         int ret;
 118
 119         mutex_lock(&evtchnl->u.req.req_io_lock);
 120
 121         mutex_lock(&evtchnl->ring_io_lock);
 122         req = be_stream_prepare_req(evtchnl, XENSND_OP_CLOSE);
 123         mutex_unlock(&evtchnl->ring_io_lock);
 124
 125         ret = be_stream_do_io(evtchnl);
 126
 127         if (ret == 0)
 128                 ret = be_stream_wait_io(evtchnl);
 129
 130         mutex_unlock(&evtchnl->u.req.req_io_lock);
 131         return ret;
 132 }
 133
 134 int xen_snd_front_stream_write(struct xen_snd_front_evtchnl *evtchnl,
 135                                unsigned long pos, unsigned long count)
 136 {
 137         struct xensnd_req *req;
 138         int ret;
 139
 140         mutex_lock(&evtchnl->u.req.req_io_lock);
 141
 142         mutex_lock(&evtchnl->ring_io_lock);
 143         req = be_stream_prepare_req(evtchnl, XENSND_OP_WRITE);
 144         req->op.rw.length = count;
 145         req->op.rw.offset = pos;
 146         mutex_unlock(&evtchnl->ring_io_lock);
 147
 148         ret = be_stream_do_io(evtchnl);
 149
 150         if (ret == 0)
 151                 ret = be_stream_wait_io(evtchnl);
 152
 153         mutex_unlock(&evtchnl->u.req.req_io_lock);
 154         return ret;
 155 }
 156
 157 int xen_snd_front_stream_read(struct xen_snd_front_evtchnl *evtchnl,
 158                               unsigned long pos, unsigned long count)
 159 {
 160         struct xensnd_req *req;
 161         int ret;
 162
 163         mutex_lock(&evtchnl->u.req.req_io_lock);
 164
 165         mutex_lock(&evtchnl->ring_io_lock);
 166         req = be_stream_prepare_req(evtchnl, XENSND_OP_READ);
 167         req->op.rw.length = count;
 168         req->op.rw.offset = pos;
 169         mutex_unlock(&evtchnl->ring_io_lock);
 170
 171         ret = be_stream_do_io(evtchnl);
 172
 173         if (ret == 0)
 174                 ret = be_stream_wait_io(evtchnl);
 175
 176         mutex_unlock(&evtchnl->u.req.req_io_lock);
 177         return ret;
 178 }
 179
 180 int xen_snd_front_stream_trigger(struct xen_snd_front_evtchnl *evtchnl,
 181                                  int type)
 182 {
 183         struct xensnd_req *req;
 184         int ret;
 185
 186         mutex_lock(&evtchnl->u.req.req_io_lock);
 187
 188         mutex_lock(&evtchnl->ring_io_lock);
 189         req = be_stream_prepare_req(evtchnl, XENSND_OP_TRIGGER);
 190         req->op.trigger.type = type;
 191         mutex_unlock(&evtchnl->ring_io_lock);
 192
 193         ret = be_stream_do_io(evtchnl);
 194
 195         if (ret == 0)
 196                 ret = be_stream_wait_io(evtchnl);
 197
 198         mutex_unlock(&evtchnl->u.req.req_io_lock);
 199         return ret;
 200 }
 201
 202 static void xen_snd_drv_fini(struct xen_snd_front_info *front_info)
 203 {
 204         xen_snd_front_alsa_fini(front_info);
 205         xen_snd_front_evtchnl_free_all(front_info);
 206 }
 207
 208 static int sndback_initwait(struct xen_snd_front_info *front_info)
 209 {
 210         int num_streams;
 211         int ret;
 212
 213         ret = xen_snd_front_cfg_card(front_info, &num_streams);
 214         if (ret < 0)
 215                 return ret;
 216
 217         /* create event channels for all streams and publish */
 218         ret = xen_snd_front_evtchnl_create_all(front_info, num_streams);
 219         if (ret < 0)
 220                 return ret;
 221
 222         return xen_snd_front_evtchnl_publish_all(front_info);
 223 }
 224
 225 static int sndback_connect(struct xen_snd_front_info *front_info)
 226 {
 227         return xen_snd_front_alsa_init(front_info);
 228 }
 229
 230 static void sndback_disconnect(struct xen_snd_front_info *front_info)
 231 {
 232         xen_snd_drv_fini(front_info);
 233         xenbus_switch_state(front_info->xb_dev, XenbusStateInitialising);
 234 }
 235
 236 static void sndback_changed(struct xenbus_device *xb_dev,
 237                             enum xenbus_state backend_state)
 238 {
 239         struct xen_snd_front_info *front_info = dev_get_drvdata(&xb_dev->dev);
 240         int ret;
 241
 242         dev_dbg(&xb_dev->dev, "Backend state is %s, front is %s\n",
 243                 xenbus_strstate(backend_state),
 244                 xenbus_strstate(xb_dev->state));
 245
 246         switch (backend_state) {
 247         case XenbusStateReconfiguring:
 248                 /* fall through */
 249         case XenbusStateReconfigured:
 250                 /* fall through */
 251         case XenbusStateInitialised:
 252                 /* fall through */
 253                 break;
 254
 255         case XenbusStateInitialising:
 256                 /* Recovering after backend unexpected closure. */
 257                 sndback_disconnect(front_info);
 258                 break;
 259
 260         case XenbusStateInitWait:
 261                 /* Recovering after backend unexpected closure. */
 262                 sndback_disconnect(front_info);
 263
 264                 ret = sndback_initwait(front_info);
 265                 if (ret < 0)
 266                         xenbus_dev_fatal(xb_dev, ret, "initializing frontend");
 267                 else
 268                         xenbus_switch_state(xb_dev, XenbusStateInitialised);
 269                 break;
 270
 271         case XenbusStateConnected:
 272                 if (xb_dev->state != XenbusStateInitialised)
 273                         break;
 274
 275                 ret = sndback_connect(front_info);
 276                 if (ret < 0)
 277                         xenbus_dev_fatal(xb_dev, ret, "initializing frontend");
 278                 else
 279                         xenbus_switch_state(xb_dev, XenbusStateConnected);
 280                 break;
 281
 282         case XenbusStateClosing:
 283                 /*
 284                  * In this state backend starts freeing resources,
 285                  * so let it go into closed state first, so we can also
 286                  * remove ours.
 287                  */
 288                 break;
 289
 290         case XenbusStateUnknown:
 291                 /* fall through */
 292         case XenbusStateClosed:
 293                 if (xb_dev->state == XenbusStateClosed)
 294                         break;
 295
 296                 sndback_disconnect(front_info);
 297                 break;
 298         }
 299 }
 300
 301 static int xen_drv_probe(struct xenbus_device *xb_dev,
 302                          const struct xenbus_device_id *id)
 303 {
 304         struct xen_snd_front_info *front_info;
 305
 306         front_info = devm_kzalloc(&xb_dev->dev,
 307                                   sizeof(*front_info), GFP_KERNEL);
 308         if (!front_info)
 309                 return -ENOMEM;
 310
 311         front_info->xb_dev = xb_dev;
 312         dev_set_drvdata(&xb_dev->dev, front_info);
 313
 314         return xenbus_switch_state(xb_dev, XenbusStateInitialising);
 315 }
 316
 317 static int xen_drv_remove(struct xenbus_device *dev)
 318 {
 319         struct xen_snd_front_info *front_info = dev_get_drvdata(&dev->dev);
 320         int to = 100;
 321
 322         xenbus_switch_state(dev, XenbusStateClosing);
 323
 324         /*
 325          * On driver removal it is disconnected from XenBus,
 326          * so no backend state change events come via .otherend_changed
 327          * callback. This prevents us from exiting gracefully, e.g.
 328          * signaling the backend to free event channels, waiting for its
 329          * state to change to XenbusStateClosed and cleaning at our end.
 330          * Normally when front driver removed backend will finally go into
 331          * XenbusStateInitWait state.
 332          *
 333          * Workaround: read backend's state manually and wait with time-out.
 334          */
 335         while ((xenbus_read_unsigned(front_info->xb_dev->otherend, "state",
 336                                      XenbusStateUnknown) != XenbusStateInitWait) &&
 337                --to)
 338                 msleep(10);
 339
 340         if (!to) {
 341                 unsigned int state;
 342
 343                 state = xenbus_read_unsigned(front_info->xb_dev->otherend,
 344                                              "state", XenbusStateUnknown);
 345                 pr_err("Backend state is %s while removing driver\n",
 346                        xenbus_strstate(state));
 347         }
 348
 349         xen_snd_drv_fini(front_info);
 350         xenbus_frontend_closed(dev);
 351         return 0;
 352 }
 353
 354 static const struct xenbus_device_id xen_drv_ids[] = {
 355         { XENSND_DRIVER_NAME },
 356         { "" }
 357 };
 358
 359 static struct xenbus_driver xen_driver = {
 360         .ids = xen_drv_ids,
 361         .probe = xen_drv_probe,
 362         .remove = xen_drv_remove,
 363         .otherend_changed = sndback_changed,
 364 };
 365
 366 static int __init xen_drv_init(void)
 367 {
 368         if (!xen_domain())
 369                 return -ENODEV;
 370
 371         if (!xen_has_pv_devices())
 372                 return -ENODEV;
 373
 374         /* At the moment we only support case with XEN_PAGE_SIZE == PAGE_SIZE */
 375         if (XEN_PAGE_SIZE != PAGE_SIZE) {
 376                 pr_err(XENSND_DRIVER_NAME ": different kernel and Xen page sizes are not supported: XEN_PAGE_SIZE (%lu) != PAGE_SIZE (%lu)\n",
 377                        XEN_PAGE_SIZE, PAGE_SIZE);
 378                 return -ENODEV;
 379         }
 380
 381         pr_info("Initialising Xen " XENSND_DRIVER_NAME " frontend driver\n");
 382         return xenbus_register_frontend(&xen_driver);
 383 }
 384
 385 static void __exit xen_drv_fini(void)
 386 {
 387         pr_info("Unregistering Xen " XENSND_DRIVER_NAME " frontend driver\n");
 388         xenbus_unregister_driver(&xen_driver);
 389 }
 390
 391 module_init(xen_drv_init);
 392 module_exit(xen_drv_fini);
 393
 394 MODULE_DESCRIPTION("Xen virtual sound device frontend");
 395 MODULE_LICENSE("GPL");
 396 MODULE_ALIAS("xen:" XENSND_DRIVER_NAME);
 397 MODULE_SUPPORTED_DEVICE("{{ALSA,Virtual soundcard}}");