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