Quelle  xen_drm_front_evtchnl.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0 OR MIT

/*
 *  Xen para-virtual DRM device
 *
 * Copyright (C) 2016-2018 EPAM Systems Inc.
 *
 * Author: Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
 */

#include <linux/errno.h>
#include <linux/irq.h>

#include <drm/drm_print.h>

#include <xen/xenbus.h>
#include <xen/events.h>
#include <xen/grant_table.h>

#include "xen_drm_front.h"
#include "xen_drm_front_evtchnl.h"

static irqreturn_t evtchnl_interrupt_ctrl(int irq, void *dev_id)
{
 struct xen_drm_front_evtchnl *evtchnl = dev_id;
 struct xen_drm_front_info *front_info = evtchnl->front_info;
 struct xendispl_resp *resp;
 RING_IDX i, rp;
 unsigned long flags;

 if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED))
  return IRQ_HANDLED;

 spin_lock_irqsave(&front_info->io_lock, flags);

again:
 rp = evtchnl->u.req.ring.sring->rsp_prod;
 /* ensure we see queued responses up to rp */
 virt_rmb();

 for (i = evtchnl->u.req.ring.rsp_cons; i != rp; i++) {
  resp = RING_GET_RESPONSE(&evtchnl->u.req.ring, i);
  if (unlikely(resp->id != evtchnl->evt_id))
   continue;

  switch (resp->operation) {
  case XENDISPL_OP_PG_FLIP:
  case XENDISPL_OP_FB_ATTACH:
  case XENDISPL_OP_FB_DETACH:
  case XENDISPL_OP_DBUF_CREATE:
  case XENDISPL_OP_DBUF_DESTROY:
  case XENDISPL_OP_SET_CONFIG:
   evtchnl->u.req.resp_status = resp->status;
   complete(&evtchnl->u.req.completion);
   break;

  default:
   DRM_ERROR("Operation %d is not supported\n",
      resp->operation);
   break;
  }
 }

 evtchnl->u.req.ring.rsp_cons = i;

 if (i != evtchnl->u.req.ring.req_prod_pvt) {
  int more_to_do;

  RING_FINAL_CHECK_FOR_RESPONSES(&evtchnl->u.req.ring,
            more_to_do);
  if (more_to_do)
   goto again;
 } else {
  evtchnl->u.req.ring.sring->rsp_event = i + 1;
 }

 spin_unlock_irqrestore(&front_info->io_lock, flags);
 return IRQ_HANDLED;
}

static irqreturn_t evtchnl_interrupt_evt(int irq, void *dev_id)
{
 struct xen_drm_front_evtchnl *evtchnl = dev_id;
 struct xen_drm_front_info *front_info = evtchnl->front_info;
 struct xendispl_event_page *page = evtchnl->u.evt.page;
 u32 cons, prod;
 unsigned long flags;

 if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED))
  return IRQ_HANDLED;

 spin_lock_irqsave(&front_info->io_lock, flags);

 prod = page->in_prod;
 /* ensure we see ring contents up to prod */
 virt_rmb();
 if (prod == page->in_cons)
  goto out;

 for (cons = page->in_cons; cons != prod; cons++) {
  struct xendispl_evt *event;

  event = &XENDISPL_IN_RING_REF(page, cons);
  if (unlikely(event->id != evtchnl->evt_id++))
   continue;

  switch (event->type) {
  case XENDISPL_EVT_PG_FLIP:
   xen_drm_front_on_frame_done(front_info, evtchnl->index,
          event->op.pg_flip.fb_cookie);
   break;
  }
 }
 page->in_cons = cons;
 /* ensure ring contents */
 virt_wmb();

out:
 spin_unlock_irqrestore(&front_info->io_lock, flags);
 return IRQ_HANDLED;
}

static void evtchnl_free(struct xen_drm_front_info *front_info,
    struct xen_drm_front_evtchnl *evtchnl)
{
 void *page = NULL;

 if (evtchnl->type == EVTCHNL_TYPE_REQ)
  page = evtchnl->u.req.ring.sring;
 else if (evtchnl->type == EVTCHNL_TYPE_EVT)
  page = evtchnl->u.evt.page;
 if (!page)
  return;

 evtchnl->state = EVTCHNL_STATE_DISCONNECTED;

 if (evtchnl->type == EVTCHNL_TYPE_REQ) {
  /* release all who still waits for response if any */
  evtchnl->u.req.resp_status = -EIO;
  complete_all(&evtchnl->u.req.completion);
 }

 if (evtchnl->irq)
  unbind_from_irqhandler(evtchnl->irq, evtchnl);

 if (evtchnl->port)
  xenbus_free_evtchn(front_info->xb_dev, evtchnl->port);

 /* end access and free the page */
 xenbus_teardown_ring(&page, 1, &evtchnl->gref);

 memset(evtchnl, 0, sizeof(*evtchnl));
}

static int evtchnl_alloc(struct xen_drm_front_info *front_info, int index,
    struct xen_drm_front_evtchnl *evtchnl,
    enum xen_drm_front_evtchnl_type type)
{
 struct xenbus_device *xb_dev = front_info->xb_dev;
 void *page;
 irq_handler_t handler;
 int ret;

 memset(evtchnl, 0, sizeof(*evtchnl));
 evtchnl->type = type;
 evtchnl->index = index;
 evtchnl->front_info = front_info;
 evtchnl->state = EVTCHNL_STATE_DISCONNECTED;

 ret = xenbus_setup_ring(xb_dev, GFP_NOIO | __GFP_HIGH, &page,
    1, &evtchnl->gref);
 if (ret)
  goto fail;

 if (type == EVTCHNL_TYPE_REQ) {
  struct xen_displif_sring *sring;

  init_completion(&evtchnl->u.req.completion);
  mutex_init(&evtchnl->u.req.req_io_lock);
  sring = page;
  XEN_FRONT_RING_INIT(&evtchnl->u.req.ring, sring, XEN_PAGE_SIZE);

  handler = evtchnl_interrupt_ctrl;
 } else {
  evtchnl->u.evt.page = page;
  handler = evtchnl_interrupt_evt;
 }

 ret = xenbus_alloc_evtchn(xb_dev, &evtchnl->port);
 if (ret < 0)
  goto fail;

 ret = bind_evtchn_to_irqhandler(evtchnl->port,
     handler, 0, xb_dev->devicetype,
     evtchnl);
 if (ret < 0)
  goto fail;

 evtchnl->irq = ret;
 return 0;

fail:
 DRM_ERROR("Failed to allocate ring: %d\n", ret);
 return ret;
}

int xen_drm_front_evtchnl_create_all(struct xen_drm_front_info *front_info)
{
 struct xen_drm_front_cfg *cfg;
 int ret, conn;

 cfg = &front_info->cfg;

 front_info->evt_pairs =
   kcalloc(cfg->num_connectors,
    sizeof(struct xen_drm_front_evtchnl_pair),
    GFP_KERNEL);
 if (!front_info->evt_pairs) {
  ret = -ENOMEM;
  goto fail;
 }

 for (conn = 0; conn < cfg->num_connectors; conn++) {
  ret = evtchnl_alloc(front_info, conn,
        &front_info->evt_pairs[conn].req,
        EVTCHNL_TYPE_REQ);
  if (ret < 0) {
   DRM_ERROR("Error allocating control channel\n");
   goto fail;
  }

  ret = evtchnl_alloc(front_info, conn,
        &front_info->evt_pairs[conn].evt,
        EVTCHNL_TYPE_EVT);
  if (ret < 0) {
   DRM_ERROR("Error allocating in-event channel\n");
   goto fail;
  }
 }
 front_info->num_evt_pairs = cfg->num_connectors;
 return 0;

fail:
 xen_drm_front_evtchnl_free_all(front_info);
 return ret;
}

static int evtchnl_publish(struct xenbus_transaction xbt,
      struct xen_drm_front_evtchnl *evtchnl,
      const char *path, const char *node_ring,
      const char *node_chnl)
{
 struct xenbus_device *xb_dev = evtchnl->front_info->xb_dev;
 int ret;

 /* write control channel ring reference */
 ret = xenbus_printf(xbt, path, node_ring, "%u", evtchnl->gref);
 if (ret < 0) {
  xenbus_dev_error(xb_dev, ret, "writing ring-ref");
  return ret;
 }

 /* write event channel ring reference */
 ret = xenbus_printf(xbt, path, node_chnl, "%u", evtchnl->port);
 if (ret < 0) {
  xenbus_dev_error(xb_dev, ret, "writing event channel");
  return ret;
 }

 return 0;
}

int xen_drm_front_evtchnl_publish_all(struct xen_drm_front_info *front_info)
{
 struct xenbus_transaction xbt;
 struct xen_drm_front_cfg *plat_data;
 int ret, conn;

 plat_data = &front_info->cfg;

again:
 ret = xenbus_transaction_start(&xbt);
 if (ret < 0) {
  xenbus_dev_fatal(front_info->xb_dev, ret,
     "starting transaction");
  return ret;
 }

 for (conn = 0; conn < plat_data->num_connectors; conn++) {
  ret = evtchnl_publish(xbt, &front_info->evt_pairs[conn].req,
          plat_data->connectors[conn].xenstore_path,
          XENDISPL_FIELD_REQ_RING_REF,
          XENDISPL_FIELD_REQ_CHANNEL);
  if (ret < 0)
   goto fail;

  ret = evtchnl_publish(xbt, &front_info->evt_pairs[conn].evt,
          plat_data->connectors[conn].xenstore_path,
          XENDISPL_FIELD_EVT_RING_REF,
          XENDISPL_FIELD_EVT_CHANNEL);
  if (ret < 0)
   goto fail;
 }

 ret = xenbus_transaction_end(xbt, 0);
 if (ret < 0) {
  if (ret == -EAGAIN)
   goto again;

  xenbus_dev_fatal(front_info->xb_dev, ret,
     "completing transaction");
  goto fail_to_end;
 }

 return 0;

fail:
 xenbus_transaction_end(xbt, 1);

fail_to_end:
 xenbus_dev_fatal(front_info->xb_dev, ret, "writing Xen store");
 return ret;
}

void xen_drm_front_evtchnl_flush(struct xen_drm_front_evtchnl *evtchnl)
{
 int notify;

 evtchnl->u.req.ring.req_prod_pvt++;
 RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&evtchnl->u.req.ring, notify);
 if (notify)
  notify_remote_via_irq(evtchnl->irq);
}

void xen_drm_front_evtchnl_set_state(struct xen_drm_front_info *front_info,
         enum xen_drm_front_evtchnl_state state)
{
 unsigned long flags;
 int i;

 if (!front_info->evt_pairs)
  return;

 spin_lock_irqsave(&front_info->io_lock, flags);
 for (i = 0; i < front_info->num_evt_pairs; i++) {
  front_info->evt_pairs[i].req.state = state;
  front_info->evt_pairs[i].evt.state = state;
 }
 spin_unlock_irqrestore(&front_info->io_lock, flags);
}

void xen_drm_front_evtchnl_free_all(struct xen_drm_front_info *front_info)
{
 int i;

 if (!front_info->evt_pairs)
  return;

 for (i = 0; i < front_info->num_evt_pairs; i++) {
  evtchnl_free(front_info, &front_info->evt_pairs[i].req);
  evtchnl_free(front_info, &front_info->evt_pairs[i].evt);
 }

 kfree(front_info->evt_pairs);
 front_info->evt_pairs = NULL;
}