1
2
3
4
5
6
7
8
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
21static 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
33again:
34 rp = channel->u.req.ring.sring->rsp_prod;
35
36 rmb();
37
38
39
40
41
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
87static 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
100 virt_rmb();
101 if (prod == page->in_cons)
102 goto out;
103
104
105
106
107
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
126 virt_wmb();
127
128out:
129 mutex_unlock(&channel->ring_io_lock);
130 return IRQ_HANDLED;
131}
132
133void 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
143static void evtchnl_free(struct xen_snd_front_info *front_info,
144 struct xen_snd_front_evtchnl *channel)
145{
146 unsigned long page = 0;
147
148 if (channel->type == EVTCHNL_TYPE_REQ)
149 page = (unsigned long)channel->u.req.ring.sring;
150 else if (channel->type == EVTCHNL_TYPE_EVT)
151 page = (unsigned long)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
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
170 if (channel->gref != GRANT_INVALID_REF)
171 gnttab_end_foreign_access(channel->gref, 0, page);
172 else
173 free_page(page);
174
175 memset(channel, 0, sizeof(*channel));
176}
177
178void xen_snd_front_evtchnl_free_all(struct xen_snd_front_info *front_info)
179{
180 int i;
181
182 if (!front_info->evt_pairs)
183 return;
184
185 for (i = 0; i < front_info->num_evt_pairs; i++) {
186 evtchnl_free(front_info, &front_info->evt_pairs[i].req);
187 evtchnl_free(front_info, &front_info->evt_pairs[i].evt);
188 }
189
190 kfree(front_info->evt_pairs);
191 front_info->evt_pairs = NULL;
192}
193
194static int evtchnl_alloc(struct xen_snd_front_info *front_info, int index,
195 struct xen_snd_front_evtchnl *channel,
196 enum xen_snd_front_evtchnl_type type)
197{
198 struct xenbus_device *xb_dev = front_info->xb_dev;
199 unsigned long page;
200 grant_ref_t gref;
201 irq_handler_t handler;
202 char *handler_name = NULL;
203 int ret;
204
205 memset(channel, 0, sizeof(*channel));
206 channel->type = type;
207 channel->index = index;
208 channel->front_info = front_info;
209 channel->state = EVTCHNL_STATE_DISCONNECTED;
210 channel->gref = GRANT_INVALID_REF;
211 page = get_zeroed_page(GFP_KERNEL);
212 if (!page) {
213 ret = -ENOMEM;
214 goto fail;
215 }
216
217 handler_name = kasprintf(GFP_KERNEL, "%s-%s", XENSND_DRIVER_NAME,
218 type == EVTCHNL_TYPE_REQ ?
219 XENSND_FIELD_RING_REF :
220 XENSND_FIELD_EVT_RING_REF);
221 if (!handler_name) {
222 ret = -ENOMEM;
223 goto fail;
224 }
225
226 mutex_init(&channel->ring_io_lock);
227
228 if (type == EVTCHNL_TYPE_REQ) {
229 struct xen_sndif_sring *sring = (struct xen_sndif_sring *)page;
230
231 init_completion(&channel->u.req.completion);
232 mutex_init(&channel->u.req.req_io_lock);
233 SHARED_RING_INIT(sring);
234 FRONT_RING_INIT(&channel->u.req.ring, sring, XEN_PAGE_SIZE);
235
236 ret = xenbus_grant_ring(xb_dev, sring, 1, &gref);
237 if (ret < 0) {
238 channel->u.req.ring.sring = NULL;
239 goto fail;
240 }
241
242 handler = evtchnl_interrupt_req;
243 } else {
244 ret = gnttab_grant_foreign_access(xb_dev->otherend_id,
245 virt_to_gfn((void *)page), 0);
246 if (ret < 0)
247 goto fail;
248
249 channel->u.evt.page = (struct xensnd_event_page *)page;
250 gref = ret;
251 handler = evtchnl_interrupt_evt;
252 }
253
254 channel->gref = gref;
255
256 ret = xenbus_alloc_evtchn(xb_dev, &channel->port);
257 if (ret < 0)
258 goto fail;
259
260 ret = bind_evtchn_to_irq(channel->port);
261 if (ret < 0) {
262 dev_err(&xb_dev->dev,
263 "Failed to bind IRQ for domid %d port %d: %d\n",
264 front_info->xb_dev->otherend_id, channel->port, ret);
265 goto fail;
266 }
267
268 channel->irq = ret;
269
270 ret = request_threaded_irq(channel->irq, NULL, handler,
271 IRQF_ONESHOT, handler_name, channel);
272 if (ret < 0) {
273 dev_err(&xb_dev->dev, "Failed to request IRQ %d: %d\n",
274 channel->irq, ret);
275 goto fail;
276 }
277
278 kfree(handler_name);
279 return 0;
280
281fail:
282 if (page)
283 free_page(page);
284 kfree(handler_name);
285 dev_err(&xb_dev->dev, "Failed to allocate ring: %d\n", ret);
286 return ret;
287}
288
289int xen_snd_front_evtchnl_create_all(struct xen_snd_front_info *front_info,
290 int num_streams)
291{
292 struct xen_front_cfg_card *cfg = &front_info->cfg;
293 struct device *dev = &front_info->xb_dev->dev;
294 int d, ret = 0;
295
296 front_info->evt_pairs =
297 kcalloc(num_streams,
298 sizeof(struct xen_snd_front_evtchnl_pair),
299 GFP_KERNEL);
300 if (!front_info->evt_pairs)
301 return -ENOMEM;
302
303
304 for (d = 0; d < cfg->num_pcm_instances; d++) {
305 struct xen_front_cfg_pcm_instance *pcm_instance;
306 int s, index;
307
308 pcm_instance = &cfg->pcm_instances[d];
309
310 for (s = 0; s < pcm_instance->num_streams_pb; s++) {
311 index = pcm_instance->streams_pb[s].index;
312
313 ret = evtchnl_alloc(front_info, index,
314 &front_info->evt_pairs[index].req,
315 EVTCHNL_TYPE_REQ);
316 if (ret < 0) {
317 dev_err(dev, "Error allocating control channel\n");
318 goto fail;
319 }
320
321 ret = evtchnl_alloc(front_info, index,
322 &front_info->evt_pairs[index].evt,
323 EVTCHNL_TYPE_EVT);
324 if (ret < 0) {
325 dev_err(dev, "Error allocating in-event channel\n");
326 goto fail;
327 }
328 }
329
330 for (s = 0; s < pcm_instance->num_streams_cap; s++) {
331 index = pcm_instance->streams_cap[s].index;
332
333 ret = evtchnl_alloc(front_info, index,
334 &front_info->evt_pairs[index].req,
335 EVTCHNL_TYPE_REQ);
336 if (ret < 0) {
337 dev_err(dev, "Error allocating control channel\n");
338 goto fail;
339 }
340
341 ret = evtchnl_alloc(front_info, index,
342 &front_info->evt_pairs[index].evt,
343 EVTCHNL_TYPE_EVT);
344 if (ret < 0) {
345 dev_err(dev, "Error allocating in-event channel\n");
346 goto fail;
347 }
348 }
349 }
350
351 front_info->num_evt_pairs = num_streams;
352 return 0;
353
354fail:
355 xen_snd_front_evtchnl_free_all(front_info);
356 return ret;
357}
358
359static int evtchnl_publish(struct xenbus_transaction xbt,
360 struct xen_snd_front_evtchnl *channel,
361 const char *path, const char *node_ring,
362 const char *node_chnl)
363{
364 struct xenbus_device *xb_dev = channel->front_info->xb_dev;
365 int ret;
366
367
368 ret = xenbus_printf(xbt, path, node_ring, "%u", channel->gref);
369 if (ret < 0) {
370 dev_err(&xb_dev->dev, "Error writing ring-ref: %d\n", ret);
371 return ret;
372 }
373
374
375 ret = xenbus_printf(xbt, path, node_chnl, "%u", channel->port);
376 if (ret < 0) {
377 dev_err(&xb_dev->dev, "Error writing event channel: %d\n", ret);
378 return ret;
379 }
380
381 return 0;
382}
383
384int xen_snd_front_evtchnl_publish_all(struct xen_snd_front_info *front_info)
385{
386 struct xen_front_cfg_card *cfg = &front_info->cfg;
387 struct xenbus_transaction xbt;
388 int ret, d;
389
390again:
391 ret = xenbus_transaction_start(&xbt);
392 if (ret < 0) {
393 xenbus_dev_fatal(front_info->xb_dev, ret,
394 "starting transaction");
395 return ret;
396 }
397
398 for (d = 0; d < cfg->num_pcm_instances; d++) {
399 struct xen_front_cfg_pcm_instance *pcm_instance;
400 int s, index;
401
402 pcm_instance = &cfg->pcm_instances[d];
403
404 for (s = 0; s < pcm_instance->num_streams_pb; s++) {
405 index = pcm_instance->streams_pb[s].index;
406
407 ret = evtchnl_publish(xbt,
408 &front_info->evt_pairs[index].req,
409 pcm_instance->streams_pb[s].xenstore_path,
410 XENSND_FIELD_RING_REF,
411 XENSND_FIELD_EVT_CHNL);
412 if (ret < 0)
413 goto fail;
414
415 ret = evtchnl_publish(xbt,
416 &front_info->evt_pairs[index].evt,
417 pcm_instance->streams_pb[s].xenstore_path,
418 XENSND_FIELD_EVT_RING_REF,
419 XENSND_FIELD_EVT_EVT_CHNL);
420 if (ret < 0)
421 goto fail;
422 }
423
424 for (s = 0; s < pcm_instance->num_streams_cap; s++) {
425 index = pcm_instance->streams_cap[s].index;
426
427 ret = evtchnl_publish(xbt,
428 &front_info->evt_pairs[index].req,
429 pcm_instance->streams_cap[s].xenstore_path,
430 XENSND_FIELD_RING_REF,
431 XENSND_FIELD_EVT_CHNL);
432 if (ret < 0)
433 goto fail;
434
435 ret = evtchnl_publish(xbt,
436 &front_info->evt_pairs[index].evt,
437 pcm_instance->streams_cap[s].xenstore_path,
438 XENSND_FIELD_EVT_RING_REF,
439 XENSND_FIELD_EVT_EVT_CHNL);
440 if (ret < 0)
441 goto fail;
442 }
443 }
444 ret = xenbus_transaction_end(xbt, 0);
445 if (ret < 0) {
446 if (ret == -EAGAIN)
447 goto again;
448
449 xenbus_dev_fatal(front_info->xb_dev, ret,
450 "completing transaction");
451 goto fail_to_end;
452 }
453 return 0;
454fail:
455 xenbus_transaction_end(xbt, 1);
456fail_to_end:
457 xenbus_dev_fatal(front_info->xb_dev, ret, "writing XenStore");
458 return ret;
459}
460
461void xen_snd_front_evtchnl_pair_set_connected(struct xen_snd_front_evtchnl_pair *evt_pair,
462 bool is_connected)
463{
464 enum xen_snd_front_evtchnl_state state;
465
466 if (is_connected)
467 state = EVTCHNL_STATE_CONNECTED;
468 else
469 state = EVTCHNL_STATE_DISCONNECTED;
470
471 mutex_lock(&evt_pair->req.ring_io_lock);
472 evt_pair->req.state = state;
473 mutex_unlock(&evt_pair->req.ring_io_lock);
474
475 mutex_lock(&evt_pair->evt.ring_io_lock);
476 evt_pair->evt.state = state;
477 mutex_unlock(&evt_pair->evt.ring_io_lock);
478}
479
480void xen_snd_front_evtchnl_pair_clear(struct xen_snd_front_evtchnl_pair *evt_pair)
481{
482 mutex_lock(&evt_pair->req.ring_io_lock);
483 evt_pair->req.evt_next_id = 0;
484 mutex_unlock(&evt_pair->req.ring_io_lock);
485
486 mutex_lock(&evt_pair->evt.ring_io_lock);
487 evt_pair->evt.evt_next_id = 0;
488 mutex_unlock(&evt_pair->evt.ring_io_lock);
489}
490
491
