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); |