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 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 /* 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 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 178 void 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 194 static 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 281 fail: 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 289 int 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 /* Iterate over devices and their streams and create event channels. */ 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 354 fail: 355 xen_snd_front_evtchnl_free_all(front_info); 356 return ret; 357 } 358 359 static 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 /* Write control channel ring reference. */ 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 /* Write event channel ring reference. */ 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 384 int 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 390 again: 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; 454 fail: 455 xenbus_transaction_end(xbt, 1); 456 fail_to_end: 457 xenbus_dev_fatal(front_info->xb_dev, ret, "writing XenStore"); 458 return ret; 459 } 460 461 void 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 480 void 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