Quelle  vbox_irq.c   Sprache: C

// SPDX-License-Identifier: MIT
/*
 * Copyright (C) 2016-2017 Oracle Corporation
 * This file is based on qxl_irq.c
 * Copyright 2013 Red Hat Inc.
 * Authors: Dave Airlie
 *          Alon Levy
 *          Michael Thayer <michael.thayer@oracle.com,
 *          Hans de Goede <hdegoede@redhat.com>
 */

#include <linux/pci.h>

#include <drm/drm_drv.h>
#include <drm/drm_probe_helper.h>

#include "vbox_drv.h"
#include "vboxvideo.h"

static void vbox_clear_irq(void)
{
 outl((u32)~0, VGA_PORT_HGSMI_HOST);
}

static u32 vbox_get_flags(struct vbox_private *vbox)
{
 return readl(vbox->guest_heap + HOST_FLAGS_OFFSET);
}

void vbox_report_hotplug(struct vbox_private *vbox)
{
 schedule_work(&vbox->hotplug_work);
}

static irqreturn_t vbox_irq_handler(int irq, void *arg)
{
 struct drm_device *dev = (struct drm_device *)arg;
 struct vbox_private *vbox = to_vbox_dev(dev);
 u32 host_flags = vbox_get_flags(vbox);

 if (!(host_flags & HGSMIHOSTFLAGS_IRQ))
  return IRQ_NONE;

 /*
 * Due to a bug in the initial host implementation of hot-plug irqs,
 * the hot-plug and cursor capability flags were never cleared.
 * Fortunately we can tell when they would have been set by checking
 * that the VSYNC flag is not set.
 */
 if (host_flags &
     (HGSMIHOSTFLAGS_HOTPLUG | HGSMIHOSTFLAGS_CURSOR_CAPABILITIES) &&
     !(host_flags & HGSMIHOSTFLAGS_VSYNC))
  vbox_report_hotplug(vbox);

 vbox_clear_irq();

 return IRQ_HANDLED;
}

/*
 * Check that the position hints provided by the host are suitable for GNOME
 * shell (i.e. all screens disjoint and hints for all enabled screens) and if
 * not replace them with default ones.  Providing valid hints improves the
 * chances that we will get a known screen layout for pointer mapping.
 */
static void validate_or_set_position_hints(struct vbox_private *vbox)
{
 struct vbva_modehint *hintsi, *hintsj;
 bool valid = true;
 u16 currentx = 0;
 int i, j;

 for (i = 0; i < vbox->num_crtcs; ++i) {
  for (j = 0; j < i; ++j) {
   hintsi = &vbox->last_mode_hints[i];
   hintsj = &vbox->last_mode_hints[j];

   if (hintsi->enabled && hintsj->enabled) {
    if (hintsi->dx >= 0xffff ||
        hintsi->dy >= 0xffff ||
        hintsj->dx >= 0xffff ||
        hintsj->dy >= 0xffff ||
        (hintsi->dx <
     hintsj->dx + (hintsj->cx & 0x8fff) &&
         hintsi->dx + (hintsi->cx & 0x8fff) >
     hintsj->dx) ||
        (hintsi->dy <
     hintsj->dy + (hintsj->cy & 0x8fff) &&
         hintsi->dy + (hintsi->cy & 0x8fff) >
     hintsj->dy))
     valid = false;
   }
  }
 }
 if (!valid)
  for (i = 0; i < vbox->num_crtcs; ++i) {
   if (vbox->last_mode_hints[i].enabled) {
    vbox->last_mode_hints[i].dx = currentx;
    vbox->last_mode_hints[i].dy = 0;
    currentx +=
        vbox->last_mode_hints[i].cx & 0x8fff;
   }
  }
}

/* Query the host for the most recent video mode hints. */
static void vbox_update_mode_hints(struct vbox_private *vbox)
{
 struct drm_connector_list_iter conn_iter;
 struct drm_device *dev = &vbox->ddev;
 struct drm_connector *connector;
 struct vbox_connector *vbox_conn;
 struct vbva_modehint *hints;
 u16 flags;
 bool disconnected;
 unsigned int crtc_id;
 int ret;

 ret = hgsmi_get_mode_hints(vbox->guest_pool, vbox->num_crtcs,
       vbox->last_mode_hints);
 if (ret) {
  DRM_ERROR("vboxvideo: hgsmi_get_mode_hints failed: %d\n", ret);
  return;
 }

 validate_or_set_position_hints(vbox);

 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
 drm_connector_list_iter_begin(dev, &conn_iter);
 drm_for_each_connector_iter(connector, &conn_iter) {
  vbox_conn = to_vbox_connector(connector);

  hints = &vbox->last_mode_hints[vbox_conn->vbox_crtc->crtc_id];
  if (hints->magic != VBVAMODEHINT_MAGIC)
   continue;

  disconnected = !(hints->enabled);
  crtc_id = vbox_conn->vbox_crtc->crtc_id;
  vbox_conn->mode_hint.width = hints->cx;
  vbox_conn->mode_hint.height = hints->cy;
  vbox_conn->vbox_crtc->x_hint = hints->dx;
  vbox_conn->vbox_crtc->y_hint = hints->dy;
  vbox_conn->mode_hint.disconnected = disconnected;

  if (vbox_conn->vbox_crtc->disconnected == disconnected)
   continue;

  if (disconnected)
   flags = VBVA_SCREEN_F_ACTIVE | VBVA_SCREEN_F_DISABLED;
  else
   flags = VBVA_SCREEN_F_ACTIVE | VBVA_SCREEN_F_BLANK;

  hgsmi_process_display_info(vbox->guest_pool, crtc_id, 0, 0, 0,
        hints->cx * 4, hints->cx,
        hints->cy, 0, flags);

  vbox_conn->vbox_crtc->disconnected = disconnected;
 }
 drm_connector_list_iter_end(&conn_iter);
 drm_modeset_unlock(&dev->mode_config.connection_mutex);
}

static void vbox_hotplug_worker(struct work_struct *work)
{
 struct vbox_private *vbox = container_of(work, struct vbox_private,
       hotplug_work);

 vbox_update_mode_hints(vbox);
 drm_kms_helper_hotplug_event(&vbox->ddev);
}

int vbox_irq_init(struct vbox_private *vbox)
{
 struct drm_device *dev = &vbox->ddev;
 struct pci_dev *pdev = to_pci_dev(dev->dev);

 INIT_WORK(&vbox->hotplug_work, vbox_hotplug_worker);
 vbox_update_mode_hints(vbox);

 /* PCI devices require shared interrupts. */
 return request_irq(pdev->irq, vbox_irq_handler, IRQF_SHARED, dev->driver->name, dev);
}

void vbox_irq_fini(struct vbox_private *vbox)
{
 struct drm_device *dev = &vbox->ddev;
 struct pci_dev *pdev = to_pci_dev(dev->dev);

 free_irq(pdev->irq, dev);
 flush_work(&vbox->hotplug_work);
}