1/**************************************************************************
  2 *
  3 * Copyright (C) 2010 VMware, Inc., Palo Alto, CA., USA
  4 * All Rights Reserved.
  5 *
  6 * Permission is hereby granted, free of charge, to any person obtaining a
  7 * copy of this software and associated documentation files (the
  8 * "Software"), to deal in the Software without restriction, including
  9 * without limitation the rights to use, copy, modify, merge, publish,
 10 * distribute, sub license, and/or sell copies of the Software, and to
 11 * permit persons to whom the Software is furnished to do so, subject to
 12 * the following conditions:
 13 *
 14 * The above copyright notice and this permission notice (including the
 15 * next paragraph) shall be included in all copies or substantial portions
 16 * of the Software.
 17 *
 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
 21 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
 22 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 23 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 24 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 25 *
 26 **************************************************************************/
 27
 28
 29#include "vmwgfx_drv.h"
 30
 31struct vmw_marker {
 32	struct list_head head;
 33	uint32_t seqno;
 34	struct timespec submitted;
 35};
 36
 37void vmw_marker_queue_init(struct vmw_marker_queue *queue)
 38{
 39	INIT_LIST_HEAD(&queue->head);
 40	queue->lag = ns_to_timespec(0);
 41	getrawmonotonic(&queue->lag_time);
 42	spin_lock_init(&queue->lock);
 43}
 44
 45void vmw_marker_queue_takedown(struct vmw_marker_queue *queue)
 46{
 47	struct vmw_marker *marker, *next;
 48
 49	spin_lock(&queue->lock);
 50	list_for_each_entry_safe(marker, next, &queue->head, head) {
 51		kfree(marker);
 52	}
 53	spin_unlock(&queue->lock);
 54}
 55
 56int vmw_marker_push(struct vmw_marker_queue *queue,
 57		   uint32_t seqno)
 58{
 59	struct vmw_marker *marker = kmalloc(sizeof(*marker), GFP_KERNEL);
 60
 61	if (unlikely(!marker))
 62		return -ENOMEM;
 63
 64	marker->seqno = seqno;
 65	getrawmonotonic(&marker->submitted);
 66	spin_lock(&queue->lock);
 67	list_add_tail(&marker->head, &queue->head);
 68	spin_unlock(&queue->lock);
 69
 70	return 0;
 71}
 72
 73int vmw_marker_pull(struct vmw_marker_queue *queue,
 74		   uint32_t signaled_seqno)
 75{
 76	struct vmw_marker *marker, *next;
 77	struct timespec now;
 78	bool updated = false;
 79
 80	spin_lock(&queue->lock);
 81	getrawmonotonic(&now);
 82
 83	if (list_empty(&queue->head)) {
 84		queue->lag = ns_to_timespec(0);
 85		queue->lag_time = now;
 86		updated = true;
 87		goto out_unlock;
 88	}
 89
 90	list_for_each_entry_safe(marker, next, &queue->head, head) {
 91		if (signaled_seqno - marker->seqno > (1 << 30))
 92			continue;
 93
 94		queue->lag = timespec_sub(now, marker->submitted);
 95		queue->lag_time = now;
 96		updated = true;
 97		list_del(&marker->head);
 98		kfree(marker);
 99	}
100
101out_unlock:
102	spin_unlock(&queue->lock);
103
104	return (updated) ? 0 : -EBUSY;
105}
106
107static struct timespec vmw_timespec_add(struct timespec t1,
108					struct timespec t2)
109{
110	t1.tv_sec += t2.tv_sec;
111	t1.tv_nsec += t2.tv_nsec;
112	if (t1.tv_nsec >= 1000000000L) {
113		t1.tv_sec += 1;
114		t1.tv_nsec -= 1000000000L;
115	}
116
117	return t1;
118}
119
120static struct timespec vmw_fifo_lag(struct vmw_marker_queue *queue)
121{
122	struct timespec now;
123
124	spin_lock(&queue->lock);
125	getrawmonotonic(&now);
126	queue->lag = vmw_timespec_add(queue->lag,
127				      timespec_sub(now, queue->lag_time));
128	queue->lag_time = now;
129	spin_unlock(&queue->lock);
130	return queue->lag;
131}
132
133
134static bool vmw_lag_lt(struct vmw_marker_queue *queue,
135		       uint32_t us)
136{
137	struct timespec lag, cond;
138
139	cond = ns_to_timespec((s64) us * 1000);
140	lag = vmw_fifo_lag(queue);
141	return (timespec_compare(&lag, &cond) < 1);
142}
143
144int vmw_wait_lag(struct vmw_private *dev_priv,
145		 struct vmw_marker_queue *queue, uint32_t us)
146{
147	struct vmw_marker *marker;
148	uint32_t seqno;
149	int ret;
150
151	while (!vmw_lag_lt(queue, us)) {
152		spin_lock(&queue->lock);
153		if (list_empty(&queue->head))
154			seqno = atomic_read(&dev_priv->marker_seq);
155		else {
156			marker = list_first_entry(&queue->head,
157						 struct vmw_marker, head);
158			seqno = marker->seqno;
159		}
160		spin_unlock(&queue->lock);
161
162		ret = vmw_wait_seqno(dev_priv, false, seqno, true,
163					3*HZ);
164
165		if (unlikely(ret != 0))
166			return ret;
167
168		(void) vmw_marker_pull(queue, seqno);
169	}
170	return 0;
171}