xen_snd_front.c 9.6 KB

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