Subversion Repositories Kolibri OS

/*

 * 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 "drm_trace.h"

#include "drm_internal.h"

#include 	/* For task queue support */

#include 

#include 

#include 

ktime_t ktime_get(void);

static inline ktime_t ktime_get_real(void)

{

	return ktime_get();

}

static inline ktime_t ktime_mono_to_real(ktime_t mono)

{

	return mono;

}

irqreturn_t device_irq_handler(struct drm_device *dev)

{

	return dev->driver->irq_handler(0, dev);

}

/* Access macro for slots in vblank timestamp ringbuffer. */

#define vblanktimestamp(dev, pipe, count) \

	((dev)->vblank[pipe].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, unsigned int pipe,

			  struct timeval *tvblank, unsigned flags);

static unsigned int drm_timestamp_precision = 20;  /* Default to 20 usecs. */

/*

 * Default to use monotonic timestamps for wait-for-vblank and page-flip

 * complete events.

 */

unsigned int drm_timestamp_monotonic = 1;

static int drm_vblank_offdelay = 5000;    /* Default to 5000 msecs. */

module_param_named(vblankoffdelay, drm_vblank_offdelay, int, 0600);

module_param_named(timestamp_precision_usec, drm_timestamp_precision, int, 0600);

module_param_named(timestamp_monotonic, drm_timestamp_monotonic, int, 0600);

static void store_vblank(struct drm_device *dev, unsigned int pipe,

			 u32 vblank_count_inc,

			 struct timeval *t_vblank, u32 last)

{

	struct drm_vblank_crtc *vblank = &dev->vblank[pipe];

	u32 tslot;

	assert_spin_locked(&dev->vblank_time_lock);

	vblank->last = last;

	/* All writers hold the spinlock, but readers are serialized by

	 * the latching of vblank->count below.

	 */

	tslot = vblank->count + vblank_count_inc;

	vblanktimestamp(dev, pipe, tslot) = *t_vblank;

	/*

	 * vblank timestamp updates are protected on the write side with

	 * vblank_time_lock, but on the read side done locklessly using a

	 * sequence-lock on the vblank counter. Ensure correct ordering using

	 * memory barrriers. We need the barrier both before and also after the

	 * counter update to synchronize with the next timestamp write.

	 * The read-side barriers for this are in drm_vblank_count_and_time.

	 */

	smp_wmb();

	vblank->count += vblank_count_inc;

	smp_wmb();

}

/**

 * drm_reset_vblank_timestamp - reset the last timestamp to the last vblank

 * @dev: DRM device

 * @pipe: index of CRTC for which to reset the timestamp

 *

 * Reset the stored timestamp for the current vblank count to correspond

 * to the last vblank occurred.

 *

 * Only to be called from drm_vblank_on().

 *

 * Note: caller must hold dev->vbl_lock since this reads & writes

 * device vblank fields.

 */

static void drm_reset_vblank_timestamp(struct drm_device *dev, unsigned int pipe)

{

	u32 cur_vblank;

	bool rc;

	struct timeval t_vblank;

	int count = DRM_TIMESTAMP_MAXRETRIES;

	spin_lock(&dev->vblank_time_lock);

	/*

	 * sample the current counter to avoid random jumps

	 * when drm_vblank_enable() applies the diff

	 */

	do {

		cur_vblank = dev->driver->get_vblank_counter(dev, pipe);

		rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, 0);

	} while (cur_vblank != dev->driver->get_vblank_counter(dev, pipe) && --count > 0);

	/*

	 * Only reinitialize corresponding vblank timestamp if high-precision query

	 * available and didn't fail. Otherwise reinitialize delayed at next vblank

	 * interrupt and assign 0 for now, to mark the vblanktimestamp as invalid.

	 */

	if (!rc)

		t_vblank = (struct timeval) {0, 0};

	/*

	 * +1 to make sure user will never see the same

	 * vblank counter value before and after a modeset

	 */

	store_vblank(dev, pipe, 1, &t_vblank, cur_vblank);

	spin_unlock(&dev->vblank_time_lock);

}

/**

 * drm_update_vblank_count - update the master vblank counter

 * @dev: DRM device

 * @pipe: counter to update

 *

 * Call back into the driver to update the appropriate vblank counter

 * (specified by @pipe).  Deal with wraparound, if it occurred, and

 * update the last read value so we can deal with wraparound on the next

 * call if necessary.

 *

 * Only necessary when going from off->on, to account for frames we

 * didn't get an interrupt for.

 *

 * Note: caller must hold dev->vbl_lock since this reads & writes

 * device vblank fields.

 */

static void drm_update_vblank_count(struct drm_device *dev, unsigned int pipe,

				    unsigned long flags)

{

	struct drm_vblank_crtc *vblank = &dev->vblank[pipe];

	u32 cur_vblank, diff;

	bool rc;

	struct timeval t_vblank;

	int count = DRM_TIMESTAMP_MAXRETRIES;

	int framedur_ns = vblank->framedur_ns;

	/*

	 * Interrupts were disabled prior to this call, so deal with counter

	 * wrap if needed.

	 * NOTE!  It's possible we lost a full dev->max_vblank_count + 1 events

	 * here if the register is small or we had vblank interrupts off for

	 * a long time.

	 *

	 * We repeat the hardware vblank counter & timestamp query until

	 * we get consistent results. This to prevent races between gpu

	 * updating its hardware counter while we are retrieving the

	 * corresponding vblank timestamp.

	 */

	do {

		cur_vblank = dev->driver->get_vblank_counter(dev, pipe);

		rc = drm_get_last_vbltimestamp(dev, pipe, &t_vblank, flags);

	} while (cur_vblank != dev->driver->get_vblank_counter(dev, pipe) && --count > 0);

	if (dev->max_vblank_count != 0) {

		/* trust the hw counter when it's around */

		diff = (cur_vblank - vblank->last) & dev->max_vblank_count;

	} else if (rc && framedur_ns) {

		const struct timeval *t_old;

		u64 diff_ns;

		t_old = &vblanktimestamp(dev, pipe, vblank->count);

		diff_ns = timeval_to_ns(&t_vblank) - timeval_to_ns(t_old);

		/*

		 * Figure out how many vblanks we've missed based

		 * on the difference in the timestamps and the

		 * frame/field duration.

		 */

		diff = DIV_ROUND_CLOSEST_ULL(diff_ns, framedur_ns);

		if (diff == 0 && flags & DRM_CALLED_FROM_VBLIRQ)

			DRM_DEBUG_VBL("crtc %u: Redundant vblirq ignored."

				      " diff_ns = %lld, framedur_ns = %d)\n",

				      pipe, (long long) diff_ns, framedur_ns);

	} else {

		/* some kind of default for drivers w/o accurate vbl timestamping */

		diff = (flags & DRM_CALLED_FROM_VBLIRQ) != 0;

	}

	/*

	 * Within a drm_vblank_pre_modeset - drm_vblank_post_modeset

	 * interval? If so then vblank irqs keep running and it will likely