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

 /**
  * \file drm_irq.c
  * IRQ 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    /* For task queue support */
 #include
 //#include
 #include
 /* Access macro for slots in vblank timestamp ringbuffer. */
 #define vblanktimestamp(dev, crtc, count) ( \
 	(dev)->_vblank_time[(crtc) * DRM_VBLANKTIME_RBSIZE + \
 	((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
 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);
+}
 /**
  * Install IRQ handler.
+ *
  * \param dev DRM device.
+ *
  * Initializes the IRQ related data. Installs the handler, calling the driver
  * \c irq_preinstall() and \c irq_postinstall() functions
  * before and after the installation.
  */
 int drm_irq_install(struct drm_device *dev)
+{
 	int ret;
     unsigned long sh_flags = 0;
 	char *irqname;
+	if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
 		return -EINVAL;
 	if (drm_dev_to_irq(dev) == 0)
 		return -EINVAL;
     mutex_lock(&dev->struct_mutex);
     /* Driver must have been initialized */
     if (!dev->dev_private) {
             mutex_unlock(&dev->struct_mutex);
             return -EINVAL;
+    }
     if (dev->irq_enabled) {
             mutex_unlock(&dev->struct_mutex);
             return -EBUSY;
+    }
     dev->irq_enabled = 1;
     mutex_unlock(&dev->struct_mutex);
     DRM_DEBUG("irq=%d\n", drm_dev_to_irq(dev));
     /* Before installing handler */
     if (dev->driver->irq_preinstall)
             dev->driver->irq_preinstall(dev);
     ret = !AttachIntHandler(drm_dev_to_irq(dev), 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 = 0;
             DRM_ERROR(__FUNCTION__);
+    }
     u16_t 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 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.
+ *
  * @crtc drm_crtc whose timestamp constants should be updated.
+ *
  */
 void drm_calc_timestamping_constants(struct drm_crtc *crtc)
+{
 	s64 linedur_ns = 0, pixeldur_ns = 0, framedur_ns = 0;
 	u64 dotclock;
 	/* Dot clock in Hz: */
 	dotclock = (u64) crtc->hwmode.clock * 1000;
 	/* Fields of interlaced scanout modes are only halve a frame duration.
 	 * Double the dotclock to get halve the frame-/line-/pixelduration.
 	 */
 	if (crtc->hwmode.flags & DRM_MODE_FLAG_INTERLACE)
 		dotclock *= 2;
 	/* Valid dotclock? */
 	if (dotclock > 0) {
 		int frame_size;
 		/* Convert scanline length in pixels and video dot clock to
 		 * line duration, frame duration and pixel duration in
 		 * nanoseconds:
 		 */
 		pixeldur_ns = (s64) div64_u64(1000000000, dotclock);
 		linedur_ns  = (s64) div64_u64(((u64) crtc->hwmode.crtc_htotal *
 					      1000000000), dotclock);
 		frame_size = crtc->hwmode.crtc_htotal *
 				crtc->hwmode.crtc_vtotal;
 		framedur_ns = (s64) div64_u64((u64) frame_size * 1000000000,
 					      dotclock);
 	} 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, crtc->hwmode.crtc_htotal,
 		  crtc->hwmode.crtc_vtotal, crtc->hwmode.crtc_vdisplay);
 	DRM_DEBUG("crtc %d: clock %d kHz framedur %d linedur %d, pixeldur %d\n",
 		  crtc->base.id, (int) dotclock/1000, (int) framedur_ns,
 		  (int) linedur_ns, (int) pixeldur_ns);
+}
+EXPORT_SYMBOL(drm_calc_timestamping_constants);
+/**
+ * drm_calc_vbltimestamp_from_scanoutpos - helper routine for kms
+ * drivers. 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.
+ *
+ * @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: drm_crtc* of crtc which defines scanout timing.
+ *
+ * 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,
+					  struct drm_crtc *refcrtc)
+{
+//	ktime_t stime, etime, mono_time_offset;
+	struct timeval tv_etime;
+	struct drm_display_mode *mode;
+	int vbl_status, vtotal, vdisplay;
+	int vpos, hpos, i;
+	s64 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;
+	}
+	mode = &refcrtc->hwmode;
+	vtotal = mode->crtc_vtotal;
+	vdisplay = mode->crtc_vdisplay;
+	/* 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 (vtotal <= 0 || vdisplay <= 0 || 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_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.
  */
 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;
     /*
      * 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_inmodeset[crtc]) {
         dev->vblank_inmodeset[crtc] = 0x1;
         if (drm_vblank_get(dev, crtc) == 0)
             dev->vblank_inmodeset[crtc] |= 0x2;
+    }
 #endif
+}
 EXPORT_SYMBOL(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_inmodeset[crtc]) {
         spin_lock_irqsave(&dev->vbl_lock, irqflags);
         dev->vblank_disable_allowed = 1;
         spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
         if (dev->vblank_inmodeset[crtc] & 0x2)
             drm_vblank_put(dev, crtc);
         dev->vblank_inmodeset[crtc] = 0;
+    }
 #endif
+}
 EXPORT_SYMBOL(drm_vblank_post_modeset);
+>
+>

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_irq.c – Rev 4104 → 4293