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 <xen/events.h>
12 #include <xen/grant_table.h>
13 #include <xen/xen.h>
14 #include <xen/xenbus.h>
15
16 #include "xen_snd_front.h"
17 #include "xen_snd_front_alsa.h"
18 #include "xen_snd_front_cfg.h"
19 #include "xen_snd_front_evtchnl.h"
20
21 static irqreturn_t evtchnl_interrupt_req(int irq, void *dev_id)
22 {
23 struct xen_snd_front_evtchnl *channel = dev_id;
24 struct xen_snd_front_info *front_info = channel->front_info;
25 struct xensnd_resp *resp;
26 RING_IDX i, rp;
27
28 if (unlikely(channel->state != EVTCHNL_STATE_CONNECTED))
29 return IRQ_HANDLED;
30
31 mutex_lock(&channel->ring_io_lock);
32
33 again:
34 rp = channel->u.req.ring.sring->rsp_prod;
35 /* Ensure we see queued responses up to rp. */
36 rmb();
37
38 /*
39 * Assume that the backend is trusted to always write sane values
40 * to the ring counters, so no overflow checks on frontend side
41 * are required.
42 */
43 for (i = channel->u.req.ring.rsp_cons; i != rp; i++) {
44 resp = RING_GET_RESPONSE(&channel->u.req.ring, i);
45 if (resp->id != channel->evt_id)
46 continue;
47 switch (resp->operation) {
48 case XENSND_OP_OPEN:
49 case XENSND_OP_CLOSE:
50 case XENSND_OP_READ:
51 case XENSND_OP_WRITE:
52 case XENSND_OP_TRIGGER:
53 channel->u.req.resp_status = resp->status;
54 complete(&channel->u.req.completion);
55 break;
56 case XENSND_OP_HW_PARAM_QUERY:
57 channel->u.req.resp_status = resp->status;
58 channel->u.req.resp.hw_param =
59 resp->resp.hw_param;
60 complete(&channel->u.req.completion);
61 break;
62
63 default:
64 dev_err(&front_info->xb_dev->dev,
65 "Operation %d is not supported\n",
66 resp->operation);
67 break;
68 }
69 }
70
71 channel->u.req.ring.rsp_cons = i;
72 if (i != channel->u.req.ring.req_prod_pvt) {
73 int more_to_do;
74
75 RING_FINAL_CHECK_FOR_RESPONSES(&channel->u.req.ring,
76 more_to_do);
77 if (more_to_do)
78 goto again;
79 } else {
80 channel->u.req.ring.sring->rsp_event = i + 1;
81 }
82
83 mutex_unlock(&channel->ring_io_lock);
84 return IRQ_HANDLED;
85 }
86
87 static irqreturn_t evtchnl_interrupt_evt(int irq, void *dev_id)
88 {
89 struct xen_snd_front_evtchnl *channel = dev_id;
90 struct xensnd_event_page *page = channel->u.evt.page;
91 u32 cons, prod;
92
93 if (unlikely(channel->state != EVTCHNL_STATE_CONNECTED))
94 return IRQ_HANDLED;
95
96 mutex_lock(&channel->ring_io_lock);
97
98 prod = page->in_prod;
99 /* Ensure we see ring contents up to prod. */
100 virt_rmb();
101 if (prod == page->in_cons)
102 goto out;
103
104 /*
105 * Assume that the backend is trusted to always write sane values
106 * to the ring counters, so no overflow checks on frontend side
107 * are required.
108 */
109 for (cons = page->in_cons; cons != prod; cons++) {
110 struct xensnd_evt *event;
111
112 event = &XENSND_IN_RING_REF(page, cons);
113 if (unlikely(event->id != channel->evt_id++))
114 continue;
115
116 switch (event->type) {
117 case XENSND_EVT_CUR_POS:
118 xen_snd_front_alsa_handle_cur_pos(channel,
119 event->op.cur_pos.position);
120 break;
121 }
122 }
123
124 page->in_cons = cons;
125 /* Ensure ring contents. */
126 virt_wmb();
127
128 out:
129 mutex_unlock(&channel->ring_io_lock);
130 return IRQ_HANDLED;
131 }
132
133 void xen_snd_front_evtchnl_flush(struct xen_snd_front_evtchnl *channel)
134 {
135 int notify;
136
137 channel->u.req.ring.req_prod_pvt++;
138 RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&channel->u.req.ring, notify);
139 if (notify)
140 notify_remote_via_irq(channel->irq);
141 }
142
143 static void evtchnl_free(struct xen_snd_front_info *front_info,
144 struct xen_snd_front_evtchnl *channel)
145 {
146 void *page = NULL;
147
148 if (channel->type == EVTCHNL_TYPE_REQ)
149 page = channel->u.req.ring.sring;
150 else if (channel->type == EVTCHNL_TYPE_EVT)
151 page = channel->u.evt.page;
152
153 if (!page)
154 return;
155
156 channel->state = EVTCHNL_STATE_DISCONNECTED;
157 if (channel->type == EVTCHNL_TYPE_REQ) {
158 /* Release all who still waits for response if any. */
159 channel->u.req.resp_status = -EIO;
160 complete_all(&channel->u.req.completion);
161 }
162
163 if (channel->irq)
164 unbind_from_irqhandler(channel->irq, channel);
165
166 if (channel->port)
167 xenbus_free_evtchn(front_info->xb_dev, channel->port);
168
169 /* End access and free the page. */
170 xenbus_teardown_ring(&page, 1, &channel->gref);
171
172 memset(channel, 0, sizeof(*channel));
173 }
174
175 void xen_snd_front_evtchnl_free_all(struct xen_snd_front_info *front_info)
176 {
177 int i;
178
179 if (!front_info->evt_pairs)
180 return;
181
182 for (i = 0; i < front_info->num_evt_pairs; i++) {
183 evtchnl_free(front_info, &front_info->evt_pairs[i].req);
184 evtchnl_free(front_info, &front_info->evt_pairs[i].evt);
185 }
186
187 kfree(front_info->evt_pairs);
188 front_info->evt_pairs = NULL;
189 }
190
191 static int evtchnl_alloc(struct xen_snd_front_info *front_info, int index,
192 struct xen_snd_front_evtchnl *channel,
193 enum xen_snd_front_evtchnl_type type)
194 {
195 struct xenbus_device *xb_dev = front_info->xb_dev;
196 void *page;
197 irq_handler_t handler;
198 char *handler_name = NULL;
199 int ret;
200
201 memset(channel, 0, sizeof(*channel));
202 channel->type = type;
203 channel->index = index;
204 channel->front_info = front_info;
205 channel->state = EVTCHNL_STATE_DISCONNECTED;
206 ret = xenbus_setup_ring(xb_dev, GFP_KERNEL, &page, 1, &channel->gref);
207 if (ret)
208 goto fail;
209
210 handler_name = kasprintf(GFP_KERNEL, "%s-%s", XENSND_DRIVER_NAME,
211 type == EVTCHNL_TYPE_REQ ?
212 XENSND_FIELD_RING_REF :
213 XENSND_FIELD_EVT_RING_REF);
214 if (!handler_name) {
215 ret = -ENOMEM;
216 goto fail;
217 }
218
219 mutex_init(&channel->ring_io_lock);
220
221 if (type == EVTCHNL_TYPE_REQ) {
222 struct xen_sndif_sring *sring = page;
223
224 init_completion(&channel->u.req.completion);
225 mutex_init(&channel->u.req.req_io_lock);
226 XEN_FRONT_RING_INIT(&channel->u.req.ring, sring, XEN_PAGE_SIZE);
227
228 handler = evtchnl_interrupt_req;
229 } else {
230 channel->u.evt.page = page;
231 handler = evtchnl_interrupt_evt;
232 }
233
234 ret = xenbus_alloc_evtchn(xb_dev, &channel->port);
235 if (ret < 0)
236 goto fail;
237
238 ret = bind_evtchn_to_irq(channel->port);
239 if (ret < 0) {
240 dev_err(&xb_dev->dev,
241 "Failed to bind IRQ for domid %d port %d: %d\n",
242 front_info->xb_dev->otherend_id, channel->port, ret);
243 goto fail;
244 }
245
246 channel->irq = ret;
247
248 ret = request_threaded_irq(channel->irq, NULL, handler,
249 IRQF_ONESHOT, handler_name, channel);
250 if (ret < 0) {
251 dev_err(&xb_dev->dev, "Failed to request IRQ %d: %d\n",
252 channel->irq, ret);
253 goto fail;
254 }
255
256 kfree(handler_name);
257 return 0;
258
259 fail:
260 kfree(handler_name);
261 dev_err(&xb_dev->dev, "Failed to allocate ring: %d\n", ret);
262 return ret;
263 }
264
265 int xen_snd_front_evtchnl_create_all(struct xen_snd_front_info *front_info,
266 int num_streams)
267 {
268 struct xen_front_cfg_card *cfg = &front_info->cfg;
269 struct device *dev = &front_info->xb_dev->dev;
270 int d, ret = 0;
271
272 front_info->evt_pairs =
273 kcalloc(num_streams,
274 sizeof(struct xen_snd_front_evtchnl_pair),
275 GFP_KERNEL);
276 if (!front_info->evt_pairs)
277 return -ENOMEM;
278
279 /* Iterate over devices and their streams and create event channels. */
280 for (d = 0; d < cfg->num_pcm_instances; d++) {
281 struct xen_front_cfg_pcm_instance *pcm_instance;
282 int s, index;
283
284 pcm_instance = &cfg->pcm_instances[d];
285
286 for (s = 0; s < pcm_instance->num_streams_pb; s++) {
287 index = pcm_instance->streams_pb[s].index;
288
289 ret = evtchnl_alloc(front_info, index,
290 &front_info->evt_pairs[index].req,
291 EVTCHNL_TYPE_REQ);
292 if (ret < 0) {
293 dev_err(dev, "Error allocating control channel\n");
294 goto fail;
295 }
296
297 ret = evtchnl_alloc(front_info, index,
298 &front_info->evt_pairs[index].evt,
299 EVTCHNL_TYPE_EVT);
300 if (ret < 0) {
301 dev_err(dev, "Error allocating in-event channel\n");
302 goto fail;
303 }
304 }
305
306 for (s = 0; s < pcm_instance->num_streams_cap; s++) {
307 index = pcm_instance->streams_cap[s].index;
308
309 ret = evtchnl_alloc(front_info, index,
310 &front_info->evt_pairs[index].req,
311 EVTCHNL_TYPE_REQ);
312 if (ret < 0) {
313 dev_err(dev, "Error allocating control channel\n");
314 goto fail;
315 }
316
317 ret = evtchnl_alloc(front_info, index,
318 &front_info->evt_pairs[index].evt,
319 EVTCHNL_TYPE_EVT);
320 if (ret < 0) {
321 dev_err(dev, "Error allocating in-event channel\n");
322 goto fail;
323 }
324 }
325 }
326
327 front_info->num_evt_pairs = num_streams;
328 return 0;
329
330 fail:
331 xen_snd_front_evtchnl_free_all(front_info);
332 return ret;
333 }
334
335 static int evtchnl_publish(struct xenbus_transaction xbt,
336 struct xen_snd_front_evtchnl *channel,
337 const char *path, const char *node_ring,
338 const char *node_chnl)
339 {
340 struct xenbus_device *xb_dev = channel->front_info->xb_dev;
341 int ret;
342
343 /* Write control channel ring reference. */
344 ret = xenbus_printf(xbt, path, node_ring, "%u", channel->gref);
345 if (ret < 0) {
346 dev_err(&xb_dev->dev, "Error writing ring-ref: %d\n", ret);
347 return ret;
348 }
349
350 /* Write event channel ring reference. */
351 ret = xenbus_printf(xbt, path, node_chnl, "%u", channel->port);
352 if (ret < 0) {
353 dev_err(&xb_dev->dev, "Error writing event channel: %d\n", ret);
354 return ret;
355 }
356
357 return 0;
358 }
359
360 int xen_snd_front_evtchnl_publish_all(struct xen_snd_front_info *front_info)
361 {
362 struct xen_front_cfg_card *cfg = &front_info->cfg;
363 struct xenbus_transaction xbt;
364 int ret, d;
365
366 again:
367 ret = xenbus_transaction_start(&xbt);
368 if (ret < 0) {
369 xenbus_dev_fatal(front_info->xb_dev, ret,
370 "starting transaction");
371 return ret;
372 }
373
374 for (d = 0; d < cfg->num_pcm_instances; d++) {
375 struct xen_front_cfg_pcm_instance *pcm_instance;
376 int s, index;
377
378 pcm_instance = &cfg->pcm_instances[d];
379
380 for (s = 0; s < pcm_instance->num_streams_pb; s++) {
381 index = pcm_instance->streams_pb[s].index;
382
383 ret = evtchnl_publish(xbt,
384 &front_info->evt_pairs[index].req,
385 pcm_instance->streams_pb[s].xenstore_path,
386 XENSND_FIELD_RING_REF,
387 XENSND_FIELD_EVT_CHNL);
388 if (ret < 0)
389 goto fail;
390
391 ret = evtchnl_publish(xbt,
392 &front_info->evt_pairs[index].evt,
393 pcm_instance->streams_pb[s].xenstore_path,
394 XENSND_FIELD_EVT_RING_REF,
395 XENSND_FIELD_EVT_EVT_CHNL);
396 if (ret < 0)
397 goto fail;
398 }
399
400 for (s = 0; s < pcm_instance->num_streams_cap; s++) {
401 index = pcm_instance->streams_cap[s].index;
402
403 ret = evtchnl_publish(xbt,
404 &front_info->evt_pairs[index].req,
405 pcm_instance->streams_cap[s].xenstore_path,
406 XENSND_FIELD_RING_REF,
407 XENSND_FIELD_EVT_CHNL);
408 if (ret < 0)
409 goto fail;
410
411 ret = evtchnl_publish(xbt,
412 &front_info->evt_pairs[index].evt,
413 pcm_instance->streams_cap[s].xenstore_path,
414 XENSND_FIELD_EVT_RING_REF,
415 XENSND_FIELD_EVT_EVT_CHNL);
416 if (ret < 0)
417 goto fail;
418 }
419 }
420 ret = xenbus_transaction_end(xbt, 0);
421 if (ret < 0) {
422 if (ret == -EAGAIN)
423 goto again;
424
425 xenbus_dev_fatal(front_info->xb_dev, ret,
426 "completing transaction");
427 goto fail_to_end;
428 }
429 return 0;
430 fail:
431 xenbus_transaction_end(xbt, 1);
432 fail_to_end:
433 xenbus_dev_fatal(front_info->xb_dev, ret, "writing XenStore");
434 return ret;
435 }
436
437 void xen_snd_front_evtchnl_pair_set_connected(struct xen_snd_front_evtchnl_pair *evt_pair,
438 bool is_connected)
439 {
440 enum xen_snd_front_evtchnl_state state;
441
442 if (is_connected)
443 state = EVTCHNL_STATE_CONNECTED;
444 else
445 state = EVTCHNL_STATE_DISCONNECTED;
446
447 mutex_lock(&evt_pair->req.ring_io_lock);
448 evt_pair->req.state = state;
449 mutex_unlock(&evt_pair->req.ring_io_lock);
450
451 mutex_lock(&evt_pair->evt.ring_io_lock);
452 evt_pair->evt.state = state;
453 mutex_unlock(&evt_pair->evt.ring_io_lock);
454 }
455
456 void xen_snd_front_evtchnl_pair_clear(struct xen_snd_front_evtchnl_pair *evt_pair)
457 {
458 mutex_lock(&evt_pair->req.ring_io_lock);
459 evt_pair->req.evt_next_id = 0;
460 mutex_unlock(&evt_pair->req.ring_io_lock);
461
462 mutex_lock(&evt_pair->evt.ring_io_lock);
463 evt_pair->evt.evt_next_id = 0;
464 mutex_unlock(&evt_pair->evt.ring_io_lock);
465 }
466
467
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.