WebSVN – Kolibri OS – Diff – /drivers/video/drm/drm_irq.c

 /*
  * drm_irq.c IRQ and vblank support
+ *
  * \author Rickard E. (Rik) Faith
  * \author Gareth Hughes
  */
 /*
  * Created: Fri Mar 19 14:30:16 1999 by faith@valinux.com
+ *
  * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
  * All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
+ *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  * OTHER DEALINGS IN THE SOFTWARE.
  */
 #include
-#include
 //#include "drm_trace.h"
+#include "drm_internal.h"
 //#include    /* For task queue support */
 #include
-//#include
+#include
 #include
 /* Access macro for slots in vblank timestamp ringbuffer. */
 #define vblanktimestamp(dev, crtc, count) \
 	((dev)->vblank[crtc].time[(count) % DRM_VBLANKTIME_RBSIZE])
 /* Retry timestamp calculation up to 3 times to satisfy
  * drm_timestamp_precision before giving up.
  */
 #define DRM_TIMESTAMP_MAXRETRIES 3
 /* Threshold in nanoseconds for detection of redundant
  * vblank irq in drm_handle_vblank(). 1 msec should be ok.
  */
 #define DRM_REDUNDANT_VBLIRQ_THRESH_NS 1000000
+static bool
+drm_get_last_vbltimestamp(struct drm_device *dev, int crtc,
+			  struct timeval *tvblank, unsigned flags);
+static unsigned int drm_timestamp_precision = 20;  /* Default to 20 usecs. */
 /*
  * Clear vblank timestamp buffer for a crtc.
  */
 #if 0
 /**
  * drm_vblank_init - initialize vblank support
  * @dev: drm_device
  * @num_crtcs: number of crtcs supported by @dev
+ *
  * This function initializes vblank support for @num_crtcs display pipelines.
+ *
  * Returns:
  * Zero on success or a negative error code on failure.
  */
 int drm_vblank_init(struct drm_device *dev, int num_crtcs)
+{
 	int i, ret = -ENOMEM;
 	spin_lock_init(&dev->vbl_lock);
 	spin_lock_init(&dev->vblank_time_lock);
 	dev->num_crtcs = num_crtcs;
 	dev->vblank = kcalloc(num_crtcs, sizeof(*dev->vblank), GFP_KERNEL);
 	if (!dev->vblank)
 		goto err;
 	for (i = 0; i < num_crtcs; i++) {
+		struct drm_vblank_crtc *vblank = &dev->vblank[i];
-		dev->vblank[i].dev = dev;
+		vblank->dev = dev;
-		dev->vblank[i].crtc = i;
+		vblank->crtc = i;
-		init_waitqueue_head(&dev->vblank[i].queue);
+		init_waitqueue_head(&vblank->queue);
-		setup_timer(&dev->vblank[i].disable_timer, vblank_disable_fn,
+		setup_timer(&vblank->disable_timer, vblank_disable_fn,
-			    (unsigned long)&dev->vblank[i]);
+			    (unsigned long)vblank);
+	}
 	DRM_INFO("Supports vblank timestamp caching Rev 2 (21.10.2013).\n");
 	/* Driver specific high-precision vblank timestamping supported? */
 	if (dev->driver->get_vblank_timestamp)
 		DRM_INFO("Driver supports precise vblank timestamp query.\n");
 	else
 		DRM_INFO("No driver support for vblank timestamp query.\n");
 	dev->vblank_disable_allowed = false;
 	return 0;
 err:
-	drm_vblank_cleanup(dev);
+	dev->num_crtcs = 0;
 	return ret;
+}
 EXPORT_SYMBOL(drm_vblank_init);
 #endif
 irqreturn_t device_irq_handler(struct drm_device *dev)
+{
 //    printf("video irq\n");
 //    printf("device %p driver %p handler %p\n", dev, dev->driver, dev->driver->irq_handler) ;
     return dev->driver->irq_handler(0, dev);
+}
 /**
  * drm_irq_install - install IRQ handler
  * @dev: DRM device
  * @irq: IRQ number to install the handler for
+ *
  * Initializes the IRQ related data. Installs the handler, calling the driver
  * irq_preinstall() and irq_postinstall() functions before and after the
  * installation.
+ *
  * This is the simplified helper interface provided for drivers with no special
  * needs. Drivers which need to install interrupt handlers for multiple
  * interrupts must instead set drm_device->irq_enabled to signal the DRM core
  * that vblank interrupts are available.
+ *
  * Returns:
  * Zero on success or a negative error code on failure.
  */
 int drm_irq_install(struct drm_device *dev, int irq)
+{
 	int ret;
     unsigned long sh_flags = 0;
 	if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
 		return -EINVAL;
 	if (irq == 0)
 		return -EINVAL;
     /* Driver must have been initialized */
 	if (!dev->dev_private)
             return -EINVAL;
 	if (dev->irq_enabled)
             return -EBUSY;
 	dev->irq_enabled = true;
 	DRM_DEBUG("irq=%d\n", irq);
     /* Before installing handler */
     if (dev->driver->irq_preinstall)
             dev->driver->irq_preinstall(dev);
     ret = !AttachIntHandler(irq, device_irq_handler, (u32)dev);
     /* After installing handler */
     if (dev->driver->irq_postinstall)
             ret = dev->driver->irq_postinstall(dev);
     if (ret < 0) {
 		dev->irq_enabled = false;
         DRM_ERROR(__FUNCTION__);
 	} else {
 		dev->irq = irq;
+    }
-    u16_t cmd = PciRead16(dev->pdev->busnr, dev->pdev->devfn, 4);
+    u16 cmd = PciRead16(dev->pdev->busnr, dev->pdev->devfn, 4);
     cmd&= ~(1<<10);
     PciWrite16(dev->pdev->busnr, dev->pdev->devfn, 4, cmd);
     return ret;
+}
 EXPORT_SYMBOL(drm_irq_install);
 u64 div64_u64(u64 dividend, u64 divisor)
+{
         u32 high, d;
         high = divisor >> 32;
         if (high) {
                 unsigned int shift = fls(high);
                 d = divisor >> shift;
                 dividend >>= shift;
         } else
                 d = divisor;
         return div_u64(dividend, d);
+}
 /**
  * drm_calc_timestamping_constants - calculate vblank timestamp constants
  * @crtc: drm_crtc whose timestamp constants should be updated.
  * @mode: display mode containing the scanout timings
+ *
  * Calculate and store various constants which are later
  * needed by vblank and swap-completion timestamping, e.g,
  * by drm_calc_vbltimestamp_from_scanoutpos(). They are
  * derived from CRTC's true scanout timing, so they take
  * things like panel scaling or other adjustments into account.
  */
 void drm_calc_timestamping_constants(struct drm_crtc *crtc,
 				     const struct drm_display_mode *mode)
+{
 	int linedur_ns = 0, pixeldur_ns = 0, framedur_ns = 0;
 	int dotclock = mode->crtc_clock;
 	/* Valid dotclock? */
 	if (dotclock > 0) {
 		int frame_size = mode->crtc_htotal * mode->crtc_vtotal;
 		/*
 		 * Convert scanline length in pixels and video
 		 * dot clock to line duration, frame duration
 		 * and pixel duration in nanoseconds:
 	 */
 		pixeldur_ns = 1000000 / dotclock;
 		linedur_ns  = div_u64((u64) mode->crtc_htotal * 1000000, dotclock);
 		framedur_ns = div_u64((u64) frame_size * 1000000, dotclock);
 		/*
 		 * Fields of interlaced scanout modes are only half a frame duration.
 		 */
 		if (mode->flags & DRM_MODE_FLAG_INTERLACE)
 			framedur_ns /= 2;
 	} else
 		DRM_ERROR("crtc %d: Can't calculate constants, dotclock = 0!\n",
 			  crtc->base.id);
 	crtc->pixeldur_ns = pixeldur_ns;
 	crtc->linedur_ns  = linedur_ns;
 	crtc->framedur_ns = framedur_ns;
 	DRM_DEBUG("crtc %d: hwmode: htotal %d, vtotal %d, vdisplay %d\n",
 		  crtc->base.id, mode->crtc_htotal,
 		  mode->crtc_vtotal, mode->crtc_vdisplay);
 	DRM_DEBUG("crtc %d: clock %d kHz framedur %d linedur %d, pixeldur %d\n",
 		  crtc->base.id, dotclock, framedur_ns,
 		  linedur_ns, pixeldur_ns);
+}
 EXPORT_SYMBOL(drm_calc_timestamping_constants);
 /**
  * drm_calc_vbltimestamp_from_scanoutpos - precise vblank timestamp helper
  * @dev: DRM device
  * @crtc: Which CRTC's vblank timestamp to retrieve
  * @max_error: Desired maximum allowable error in timestamps (nanosecs)
  *             On return contains true maximum error of timestamp
  * @vblank_time: Pointer to struct timeval which should receive the timestamp
  * @flags: Flags to pass to driver:
  *         0 = Default,
  *         DRM_CALLED_FROM_VBLIRQ = If function is called from vbl IRQ handler
  * @refcrtc: CRTC which defines scanout timing
  * @mode: mode which defines the scanout timings
+ *
  * Implements calculation of exact vblank timestamps from given drm_display_mode
  * timings and current video scanout position of a CRTC. This can be called from
  * within get_vblank_timestamp() implementation of a kms driver to implement the
  * actual timestamping.
+ *
  * Should return timestamps conforming to the OML_sync_control OpenML
  * extension specification. The timestamp corresponds to the end of
  * the vblank interval, aka start of scanout of topmost-leftmost display
  * pixel in the following video frame.
+ *
  * Requires support for optional dev->driver->get_scanout_position()
  * in kms driver, plus a bit of setup code to provide a drm_display_mode
  * that corresponds to the true scanout timing.
+ *
  * The current implementation only handles standard video modes. It
  * returns as no operation if a doublescan or interlaced video mode is
  * active. Higher level code is expected to handle this.
+ *
  * Returns:
  * Negative value on error, failure or if not supported in current
  * video mode:
+ *
  * -EINVAL   - Invalid CRTC.
  * -EAGAIN   - Temporary unavailable, e.g., called before initial modeset.
  * -ENOTSUPP - Function not supported in current display mode.
  * -EIO      - Failed, e.g., due to failed scanout position query.
+ *
  * Returns or'ed positive status flags on success:
+ *
  * DRM_VBLANKTIME_SCANOUTPOS_METHOD - Signal this method used for timestamping.
  * DRM_VBLANKTIME_INVBL - Timestamp taken while scanout was in vblank interval.
+ *
  */
 int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev, int crtc,
 					  int *max_error,
 					  struct timeval *vblank_time,
 					  unsigned flags,
 					  const struct drm_crtc *refcrtc,
 					  const struct drm_display_mode *mode)
+{
 	struct timeval tv_etime;
 	int vbl_status;
 	int vpos, hpos, i;
 	int framedur_ns, linedur_ns, pixeldur_ns, delta_ns, duration_ns;
 	bool invbl;
 	if (crtc < 0 || crtc >= dev->num_crtcs) {
 		DRM_ERROR("Invalid crtc %d\n", crtc);
 		return -EINVAL;
+	}
 	/* Scanout position query not supported? Should not happen. */
 	if (!dev->driver->get_scanout_position) {
 		DRM_ERROR("Called from driver w/o get_scanout_position()!?\n");
 		return -EIO;
+	}
 	/* Durations of frames, lines, pixels in nanoseconds. */
 	framedur_ns = refcrtc->framedur_ns;
 	linedur_ns  = refcrtc->linedur_ns;
 	pixeldur_ns = refcrtc->pixeldur_ns;
 	/* If mode timing undefined, just return as no-op:
 	 * Happens during initial modesetting of a crtc.
 	 */
 	if (framedur_ns == 0) {
 		DRM_DEBUG("crtc %d: Noop due to uninitialized mode.\n", crtc);
 		return -EAGAIN;
+	}
 	return -EIO;
+}
 EXPORT_SYMBOL(drm_calc_vbltimestamp_from_scanoutpos);
 /**
+ * drm_vblank_get - get a reference count on vblank events
+ * @dev: DRM device
+ * @crtc: which CRTC to own
+ *
+ * Acquire a reference count on vblank events to avoid having them disabled
+ * while in use.
+ *
+ * This is the legacy version of drm_crtc_vblank_get().
+ *
+ * Returns:
+ * Zero on success, nonzero on failure.
+ */
+int drm_vblank_get(struct drm_device *dev, int crtc)
+{
+	struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
+	unsigned long irqflags;
+	int ret = 0;
+#if 0
+	if (WARN_ON(crtc >= dev->num_crtcs))
+		return -EINVAL;
+	spin_lock_irqsave(&dev->vbl_lock, irqflags);
+	/* Going from 0->1 means we have to enable interrupts again */
+	if (atomic_add_return(1, &vblank->refcount) == 1) {
+		ret = drm_vblank_enable(dev, crtc);
+	} else {
+		if (!vblank->enabled) {
+			atomic_dec(&vblank->refcount);
+			ret = -EINVAL;
+		}
+	}
+	spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
+#endif
+	return ret;
+}
+EXPORT_SYMBOL(drm_vblank_get);
+/**
+ * drm_crtc_vblank_get - get a reference count on vblank events
+ * @crtc: which CRTC to own
+ *
+ * Acquire a reference count on vblank events to avoid having them disabled
+ * while in use.
+ *
+ * This is the native kms version of drm_vblank_off().
+ *
+ * Returns:
+ * Zero on success, nonzero on failure.
+ */
+int drm_crtc_vblank_get(struct drm_crtc *crtc)
+{
+	return drm_vblank_get(crtc->dev, drm_crtc_index(crtc));
+}
+EXPORT_SYMBOL(drm_crtc_vblank_get);
+/**
+ * drm_vblank_put - give up ownership of vblank events
+ * @dev: DRM device
+ * @crtc: which counter to give up
+ *
+ * Release ownership of a given vblank counter, turning off interrupts
+ * if possible. Disable interrupts after drm_vblank_offdelay milliseconds.
+ *
+ * This is the legacy version of drm_crtc_vblank_put().
+ */
+void drm_vblank_put(struct drm_device *dev, int crtc)
+{
+#if 0
+	struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
+	if (WARN_ON(atomic_read(&vblank->refcount) == 0))
+		return;
+	if (WARN_ON(crtc >= dev->num_crtcs))
+		return;
+	/* Last user schedules interrupt disable */
+	if (atomic_dec_and_test(&vblank->refcount)) {
+		if (drm_vblank_offdelay == 0)
+			return;
+		else if (dev->vblank_disable_immediate || drm_vblank_offdelay < 0)
+			vblank_disable_fn((unsigned long)vblank);
+		else
+			mod_timer(&vblank->disable_timer,
+				  jiffies + ((drm_vblank_offdelay * HZ)/1000));
+	}
+#endif
+}
+EXPORT_SYMBOL(drm_vblank_put);
+/**
+ * drm_crtc_vblank_put - give up ownership of vblank events
+ * @crtc: which counter to give up
+ *
+ * Release ownership of a given vblank counter, turning off interrupts
+ * if possible. Disable interrupts after drm_vblank_offdelay milliseconds.
+ *
+ * This is the native kms version of drm_vblank_put().
+ */
+void drm_crtc_vblank_put(struct drm_crtc *crtc)
+{
+	drm_vblank_put(crtc->dev, drm_crtc_index(crtc));
+}
+EXPORT_SYMBOL(drm_crtc_vblank_put);
+/**
+ * drm_wait_one_vblank - wait for one vblank
+ * @dev: DRM device
+ * @crtc: crtc index
+ *
+ * This waits for one vblank to pass on @crtc, using the irq driver interfaces.
+ * It is a failure to call this when the vblank irq for @crtc is disabled, e.g.
+ * due to lack of driver support or because the crtc is off.
+ */
+void drm_wait_one_vblank(struct drm_device *dev, int crtc)
+{
+#if 0
+	int ret;
+	u32 last;
+	ret = drm_vblank_get(dev, crtc);
+	if (WARN(ret, "vblank not available on crtc %i, ret=%i\n", crtc, ret))
+		return;
+	last = drm_vblank_count(dev, crtc);
+	ret = wait_event_timeout(dev->vblank[crtc].queue,
+				 last != drm_vblank_count(dev, crtc),
+				 msecs_to_jiffies(100));
+	WARN(ret == 0, "vblank wait timed out on crtc %i\n", crtc);
+	drm_vblank_put(dev, crtc);
+#endif
+}
+EXPORT_SYMBOL(drm_wait_one_vblank);
+/**
+ * drm_crtc_wait_one_vblank - wait for one vblank
+ * @crtc: DRM crtc
+ *
+ * This waits for one vblank to pass on @crtc, using the irq driver interfaces.
+ * It is a failure to call this when the vblank irq for @crtc is disabled, e.g.
+ * due to lack of driver support or because the crtc is off.
+ */
+void drm_crtc_wait_one_vblank(struct drm_crtc *crtc)
+{
+	drm_wait_one_vblank(crtc->dev, drm_crtc_index(crtc));
+}
+EXPORT_SYMBOL(drm_crtc_wait_one_vblank);
+/**
  * drm_vblank_off - disable vblank events on a CRTC
  * @dev: DRM device
  * @crtc: CRTC in question
+ *
  * Drivers can use this function to shut down the vblank interrupt handling when
  * disabling a crtc. This function ensures that the latest vblank frame count is
  * stored so that drm_vblank_on() can restore it again.
+ *
  * Drivers must use this function when the hardware vblank counter can get
  * reset, e.g. when suspending.
+ *
  * This is the legacy version of drm_crtc_vblank_off().
  */
 void drm_vblank_off(struct drm_device *dev, int crtc)
+{
+	struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
 	struct drm_pending_vblank_event *e, *t;
 	struct timeval now;
 	unsigned long irqflags;
 	unsigned int seq;
+}
 EXPORT_SYMBOL(drm_vblank_off);
 /**
  * drm_crtc_vblank_off - disable vblank events on a CRTC
  * @crtc: CRTC in question
+ *
  * Drivers can use this function to shut down the vblank interrupt handling when
  * disabling a crtc. This function ensures that the latest vblank frame count is
  * stored so that drm_vblank_on can restore it again.
+ *
  * Drivers must use this function when the hardware vblank counter can get
  * reset, e.g. when suspending.
+ *
  * This is the native kms version of drm_vblank_off().
  */
 void drm_crtc_vblank_off(struct drm_crtc *crtc)
+{
 	drm_vblank_off(crtc->dev, drm_crtc_index(crtc));
+}
 EXPORT_SYMBOL(drm_crtc_vblank_off);
 /**
  * drm_vblank_on - enable vblank events on a CRTC
  * @dev: DRM device
  * @crtc: CRTC in question
+ *
  * This functions restores the vblank interrupt state captured with
  * drm_vblank_off() again. Note that calls to drm_vblank_on() and
- * drm_vblank_off() can be unbalanced and so can also be unconditionaly called
+ * drm_vblank_off() can be unbalanced and so can also be unconditionally called
  * in driver load code to reflect the current hardware state of the crtc.
+ *
  * This is the legacy version of drm_crtc_vblank_on().
  */
 void drm_vblank_on(struct drm_device *dev, int crtc)
+{
+	struct drm_vblank_crtc *vblank = &dev->vblank[crtc];
 	unsigned long irqflags;
+}
 EXPORT_SYMBOL(drm_vblank_on);
 /**
  * drm_crtc_vblank_on - enable vblank events on a CRTC
  * @crtc: CRTC in question
+ *
  * This functions restores the vblank interrupt state captured with
  * drm_vblank_off() again. Note that calls to drm_vblank_on() and
- * drm_vblank_off() can be unbalanced and so can also be unconditionaly called
+ * drm_vblank_off() can be unbalanced and so can also be unconditionally called
  * in driver load code to reflect the current hardware state of the crtc.
+ *
  * This is the native kms version of drm_vblank_on().
  */
 void drm_crtc_vblank_on(struct drm_crtc *crtc)
+{
 	drm_vblank_on(crtc->dev, drm_crtc_index(crtc));
+}
 EXPORT_SYMBOL(drm_crtc_vblank_on);
 /**
  * drm_vblank_pre_modeset - account for vblanks across mode sets
  * @dev: DRM device
  * @crtc: CRTC in question
+ *
  * Account for vblank events across mode setting events, which will likely
  * reset the hardware frame counter.
+ *
  * This is done by grabbing a temporary vblank reference to ensure that the
  * vblank interrupt keeps running across the modeset sequence. With this the
  * software-side vblank frame counting will ensure that there are no jumps or
  * discontinuities.
+ *
  * Unfortunately this approach is racy and also doesn't work when the vblank
  * interrupt stops running, e.g. across system suspend resume. It is therefore
  * highly recommended that drivers use the newer drm_vblank_off() and
  * drm_vblank_on() instead. drm_vblank_pre_modeset() only works correctly when
  * using "cooked" software vblank frame counters and not relying on any hardware
  * counters.
+ *
  * Drivers must call drm_vblank_post_modeset() when re-enabling the same crtc
  * again.
  */
 void drm_vblank_pre_modeset(struct drm_device *dev, int crtc)
+{
 #if 0
     /* vblank is not initialized (IRQ not installed ?) */
     if (!dev->num_crtcs)
         return;
+	if (WARN_ON(crtc >= dev->num_crtcs))
+		return;
     /*
      * To avoid all the problems that might happen if interrupts
      * were enabled/disabled around or between these calls, we just
      * have the kernel take a reference on the CRTC (just once though
      * to avoid corrupting the count if multiple, mismatch calls occur),
      * so that interrupts remain enabled in the interim.
      */
-	if (!dev->vblank[crtc].inmodeset) {
+	if (!vblank->inmodeset) {
-		dev->vblank[crtc].inmodeset = 0x1;
+		vblank->inmodeset = 0x1;
         if (drm_vblank_get(dev, crtc) == 0)
-			dev->vblank[crtc].inmodeset |= 0x2;
+			vblank->inmodeset |= 0x2;
+    }
 #endif
+}
 EXPORT_SYMBOL(drm_vblank_pre_modeset);
 /**
  * drm_vblank_post_modeset - undo drm_vblank_pre_modeset changes
  * @dev: DRM device
  * @crtc: CRTC in question
+ *
  * This function again drops the temporary vblank reference acquired in
  * drm_vblank_pre_modeset.
  */
 void drm_vblank_post_modeset(struct drm_device *dev, int crtc)
+{
 #if 0
     unsigned long irqflags;
 	/* vblank is not initialized (IRQ not installed ?), or has been freed */
 	if (!dev->num_crtcs)
 		return;
-	if (dev->vblank[crtc].inmodeset) {
+	if (vblank->inmodeset) {
         spin_lock_irqsave(&dev->vbl_lock, irqflags);
 		dev->vblank_disable_allowed = true;
         spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
-		if (dev->vblank[crtc].inmodeset & 0x2)
+		if (vblank->inmodeset & 0x2)
             drm_vblank_put(dev, crtc);
-		dev->vblank[crtc].inmodeset = 0;
+		vblank->inmodeset = 0;
+    }
 #endif
+}
 EXPORT_SYMBOL(drm_vblank_post_modeset);
+>
+>

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_irq.c – Rev 5060 → 5271