Subversion Repositories Kolibri OS

Rev

Rev 2004 | Rev 2997 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2004 Rev 2005
Line 99... Line 99...
99 
	struct list_head *i, *n;
 99 
	struct list_head *i, *n;
100 
	uint32_t seq;
 100 
	uint32_t seq;
101 
	bool wake = false;
 101 
	bool wake = false;
102 
	unsigned long cjiffies;
 102 
	unsigned long cjiffies;
Line 103... Line -...
103 
 
 - 
 
104 
#if 0
 103 
 
105 
	seq = radeon_fence_read(rdev);
 104 
	seq = radeon_fence_read(rdev);
106 
	if (seq != rdev->fence_drv.last_seq) {
 105 
	if (seq != rdev->fence_drv.last_seq) {
107 
		rdev->fence_drv.last_seq = seq;
 106 
		rdev->fence_drv.last_seq = seq;
108 
		rdev->fence_drv.last_jiffies = jiffies;
 107 
        rdev->fence_drv.last_jiffies = GetTimerTicks();
109 
//       rdev->fence_drv.last_timeout = RADEON_FENCE_JIFFIES_TIMEOUT;
 108 
        rdev->fence_drv.last_timeout = RADEON_FENCE_JIFFIES_TIMEOUT;
110 
	} else {
 109 
	} else {
111 
		cjiffies = jiffies;
 110 
        cjiffies = GetTimerTicks();
112 
		if (time_after(cjiffies, rdev->fence_drv.last_jiffies)) {
 111 
		if (time_after(cjiffies, rdev->fence_drv.last_jiffies)) {
113 
			cjiffies -= rdev->fence_drv.last_jiffies;
 112 
			cjiffies -= rdev->fence_drv.last_jiffies;
114 
			if (time_after(rdev->fence_drv.last_timeout, cjiffies)) {
 113 
			if (time_after(rdev->fence_drv.last_timeout, cjiffies)) {
115 
				/* update the timeout */
 114 
				/* update the timeout */
Line 136... Line 135...
136 
			break;
 135 
			break;
137 
		}
 136 
		}
138 
	}
 137 
	}
139 
	/* all fence previous to this one are considered as signaled */
 138 
	/* all fence previous to this one are considered as signaled */
140 
	if (n) {
 139 
	if (n) {
- 
 
 140 
        kevent_t event;
- 
 
 141 
        event.code = -1;
141 
		i = n;
 142 
		i = n;
142 
		do {
 143 
		do {
143 
			n = i->prev;
 144 
			n = i->prev;
144 
			list_move_tail(i, &rdev->fence_drv.signaled);
 145 
			list_move_tail(i, &rdev->fence_drv.signaled);
145 
			fence = list_entry(i, struct radeon_fence, list);
 146 
			fence = list_entry(i, struct radeon_fence, list);
146 
			fence->signaled = true;
 147 
			fence->signaled = true;
- 
 
 148 
//            dbgprintf("fence %x done\n", fence);
- 
 
 149 
            RaiseEvent(fence->evnt, 0, &event);
147 
			i = n;
 150 
			i = n;
148 
		} while (i != &rdev->fence_drv.emited);
 151 
		} while (i != &rdev->fence_drv.emited);
149 
		wake = true;
 152 
		wake = true;
150 
	}
 153 
	}
151 
#endif
 - 
 
152 
	return wake;
 154 
	return wake;
153 
}
 155 
}
Line 154... Line -...
154 
 
 - 
 
155 
static void radeon_fence_destroy(struct kref *kref)
 - 
 
156 
{
 - 
 
157 
	unsigned long irq_flags;
 - 
 
158 
        struct radeon_fence *fence;
 - 
 
159 
 
 - 
 
160 
	fence = container_of(kref, struct radeon_fence, kref);
 - 
 
161 
	write_lock_irqsave(&fence->rdev->fence_drv.lock, irq_flags);
 - 
 
162 
	list_del(&fence->list);
 - 
 
163 
	fence->emited = false;
 - 
 
164 
	write_unlock_irqrestore(&fence->rdev->fence_drv.lock, irq_flags);
 - 
 
165 
	kfree(fence);
 - 
 
Line 166... Line 156...
166 
}
 156 
 
167 
 
 157 
 
168 
int radeon_fence_create(struct radeon_device *rdev, struct radeon_fence **fence)
 158 
int radeon_fence_create(struct radeon_device *rdev, struct radeon_fence **fence)
Line 169... Line 159...
169 
{
 159 
{
170 
	unsigned long irq_flags;
 160 
	unsigned long irq_flags;
171 
 
 161 
 
172 
	*fence = kmalloc(sizeof(struct radeon_fence), GFP_KERNEL);
 162 
	*fence = kmalloc(sizeof(struct radeon_fence), GFP_KERNEL);
- 
 
 163 
	if ((*fence) == NULL) {
- 
 
 164 
		return -ENOMEM;
173 
	if ((*fence) == NULL) {
 165 
	}
174 
		return -ENOMEM;
 166 
 
175 
	}
 167 
    (*fence)->evnt = CreateEvent(NULL, MANUAL_DESTROY);
176 
//	kref_init(&((*fence)->kref));
 168 
//	kref_init(&((*fence)->kref));
177 
	(*fence)->rdev = rdev;
 169 
	(*fence)->rdev = rdev;
Line 229... Line 221...
229 
	}
 221 
	}
230 
	rdev = fence->rdev;
 222 
	rdev = fence->rdev;
231 
	if (radeon_fence_signaled(fence)) {
 223 
	if (radeon_fence_signaled(fence)) {
232 
		return 0;
 224 
		return 0;
233 
	}
 225 
	}
234 
 
 - 
 
235 
#if 0
 - 
 
236 
	timeout = rdev->fence_drv.last_timeout;
 226 
	timeout = rdev->fence_drv.last_timeout;
237 
retry:
 227 
retry:
238 
	/* save current sequence used to check for GPU lockup */
 228 
	/* save current sequence used to check for GPU lockup */
239 
	seq = rdev->fence_drv.last_seq;
 229 
	seq = rdev->fence_drv.last_seq;
240 
//   trace_radeon_fence_wait_begin(rdev->ddev, seq);
 230 
//   trace_radeon_fence_wait_begin(rdev->ddev, seq);
241 
	if (intr) {
 231 
	if (intr) {
242 
		radeon_irq_kms_sw_irq_get(rdev);
 232 
		radeon_irq_kms_sw_irq_get(rdev);
243 
		r = wait_event_interruptible_timeout(rdev->fence_drv.queue,
 233 
//       r = wait_event_interruptible_timeout(rdev->fence_drv.queue,
244 
				radeon_fence_signaled(fence), timeout);
 234 
//               radeon_fence_signaled(fence), timeout);
- 
 
 235 
 
- 
 
 236 
        WaitEvent(fence->evnt);
- 
 
 237 
 
245 
		radeon_irq_kms_sw_irq_put(rdev);
 238 
		radeon_irq_kms_sw_irq_put(rdev);
246 
		if (unlikely(r < 0)) {
 239 
		if (unlikely(r < 0)) {
247 
			return r;
 240 
			return r;
248 
		}
 241 
		}
249 
	} else {
 242 
	} else {
250 
		radeon_irq_kms_sw_irq_get(rdev);
 243 
		radeon_irq_kms_sw_irq_get(rdev);
251 
		r = wait_event_timeout(rdev->fence_drv.queue,
 244 
//       r = wait_event_timeout(rdev->fence_drv.queue,
252 
			 radeon_fence_signaled(fence), timeout);
 245 
//            radeon_fence_signaled(fence), timeout);
- 
 
 246 
 
- 
 
 247 
        WaitEvent(fence->evnt);
- 
 
 248 
 
253 
		radeon_irq_kms_sw_irq_put(rdev);
 249 
		radeon_irq_kms_sw_irq_put(rdev);
254 
	}
 250 
	}
255 
//   trace_radeon_fence_wait_end(rdev->ddev, seq);
 251 
//   trace_radeon_fence_wait_end(rdev->ddev, seq);
256 
	if (unlikely(!radeon_fence_signaled(fence))) {
 252 
	if (unlikely(!radeon_fence_signaled(fence))) {
257 
		/* we were interrupted for some reason and fence isn't
 253 
		/* we were interrupted for some reason and fence isn't
Line 270... Line 266...
270 
			     fence->seq, seq);
 266 
			     fence->seq, seq);
271 
			/* FIXME: what should we do ? marking everyone
 267 
			/* FIXME: what should we do ? marking everyone
272 
			 * as signaled for now
 268 
			 * as signaled for now
273 
			 */
 269 
			 */
274 
			rdev->gpu_lockup = true;
 270 
			rdev->gpu_lockup = true;
275 
			r = radeon_gpu_reset(rdev);
 271 
//           r = radeon_gpu_reset(rdev);
276 
			if (r)
 272 
//           if (r)
- 
 
 273 
//               return r;
277 
				return r;
 274 
            return true;
- 
 
 275 
 
278 
			radeon_fence_write(rdev, fence->seq);
 276 
//           radeon_fence_write(rdev, fence->seq);
279 
			rdev->gpu_lockup = false;
 277 
//           rdev->gpu_lockup = false;
280 
			}
 278 
			}
281 
//       timeout = RADEON_FENCE_JIFFIES_TIMEOUT;
 279 
        timeout = RADEON_FENCE_JIFFIES_TIMEOUT;
282 
		write_lock_irqsave(&rdev->fence_drv.lock, irq_flags);
 280 
		write_lock_irqsave(&rdev->fence_drv.lock, irq_flags);
283 
//       rdev->fence_drv.last_timeout = RADEON_FENCE_JIFFIES_TIMEOUT;
 281 
        rdev->fence_drv.last_timeout = RADEON_FENCE_JIFFIES_TIMEOUT;
284 
//       rdev->fence_drv.last_jiffies = jiffies;
 282 
        rdev->fence_drv.last_jiffies = GetTimerTicks();
285 
		write_unlock_irqrestore(&rdev->fence_drv.lock, irq_flags);
 283 
		write_unlock_irqrestore(&rdev->fence_drv.lock, irq_flags);
286 
		goto retry;
 284 
		goto retry;
287 
	}
 285 
	}
288 
#endif
 - 
 
289 
	return 0;
 286 
	return 0;
290 
}
 287 
}
Line 291... Line 288...
291 
 
 288 
 
292 
#if 0
 289 
#if 0
Line 344... Line 341...
344 
 
 341 
 
Line 345... Line 342...
345 
#endif
 342 
#endif
346 
 
 343 
 
- 
 
 344 
void radeon_fence_unref(struct radeon_fence **fence)
347 
void radeon_fence_unref(struct radeon_fence **fence)
 345 
{
Line 348... Line 346...
348 
{
 346 
    unsigned long irq_flags;
- 
 
 347 
	struct radeon_fence *tmp = *fence;
- 
 
 348 
 
- 
 
 349 
	*fence = NULL;
- 
 
 350 
 
- 
 
 351 
    if(tmp)
- 
 
 352 
    {
- 
 
 353 
        write_lock_irqsave(&tmp->rdev->fence_drv.lock, irq_flags);
- 
 
 354 
        list_del(&tmp->list);
349 
	struct radeon_fence *tmp = *fence;
 355 
        tmp->emited = false;
Line 350... Line -...
350 
 
 - 
 
351 
	*fence = NULL;
 356 
        write_unlock_irqrestore(&tmp->rdev->fence_drv.lock, irq_flags);
352 
}
 357 
    };
353 
 
 358 
}
354 
#if 0
 359 
 
Line 355... Line 360...
355 
void radeon_fence_process(struct radeon_device *rdev)
 360 
void radeon_fence_process(struct radeon_device *rdev)
356 
{
 361 
{
357 
	unsigned long irq_flags;
 362 
	unsigned long irq_flags;
358 
	bool wake;
 - 
 
359 
 
 - 
 
360 
	write_lock_irqsave(&rdev->fence_drv.lock, irq_flags);
 363 
	bool wake;
361 
	wake = radeon_fence_poll_locked(rdev);
 - 
 
362 
	write_unlock_irqrestore(&rdev->fence_drv.lock, irq_flags);
 - 
 
363 
	if (wake) {
 - 
 
Line 364... Line 364...
364 
		wake_up_all(&rdev->fence_drv.queue);
 364 
 
365 
	}
 365 
	write_lock_irqsave(&rdev->fence_drv.lock, irq_flags);
366 
}
 366 
	wake = radeon_fence_poll_locked(rdev);
367 
 
 367 
	write_unlock_irqrestore(&rdev->fence_drv.lock, irq_flags);