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