1/* 2 * Copyright 2014 Advanced Micro Devices, Inc. 3 * All Rights Reserved. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the 7 * "Software"), to deal in the Software without restriction, including 8 * without limitation the rights to use, copy, modify, merge, publish, 9 * distribute, sub license, and/or sell copies of the Software, and to 10 * permit persons to whom the Software is furnished to do so, subject to 11 * the following conditions: 12 * 13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 16 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, 17 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 18 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 19 * USE OR OTHER DEALINGS IN THE SOFTWARE. 20 * 21 * The above copyright notice and this permission notice (including the 22 * next paragraph) shall be included in all copies or substantial portions 23 * of the Software. 24 * 25 */ 26/* 27 * Authors: 28 * Christian König <christian.koenig@amd.com> 29 */ 30 31#include "radeon.h" 32#include "radeon_trace.h" 33 34/** 35 * radeon_sync_create - zero init sync object 36 * 37 * @sync: sync object to initialize 38 * 39 * Just clear the sync object for now. 40 */ 41void radeon_sync_create(struct radeon_sync *sync) 42{ 43 unsigned i; 44 45 for (i = 0; i < RADEON_NUM_SYNCS; ++i) 46 sync->semaphores[i] = NULL; 47 48 for (i = 0; i < RADEON_NUM_RINGS; ++i) 49 sync->sync_to[i] = NULL; 50 51 sync->last_vm_update = NULL; 52} 53 54/** 55 * radeon_sync_fence - use the semaphore to sync to a fence 56 * 57 * @sync: sync object to add fence to 58 * @fence: fence to sync to 59 * 60 * Sync to the fence using the semaphore objects 61 */ 62void radeon_sync_fence(struct radeon_sync *sync, 63 struct radeon_fence *fence) 64{ 65 struct radeon_fence *other; 66 67 if (!fence) 68 return; 69 70 other = sync->sync_to[fence->ring]; 71 sync->sync_to[fence->ring] = radeon_fence_later(fence, other); 72 73 if (fence->is_vm_update) { 74 other = sync->last_vm_update; 75 sync->last_vm_update = radeon_fence_later(fence, other); 76 } 77} 78 79/** 80 * radeon_sync_resv - use the semaphores to sync to a reservation object 81 * 82 * @sync: sync object to add fences from reservation object to 83 * @resv: reservation object with embedded fence 84 * @shared: true if we should only sync to the exclusive fence 85 * 86 * Sync to the fence using the semaphore objects 87 */ 88int radeon_sync_resv(struct radeon_device *rdev, 89 struct radeon_sync *sync, 90 struct dma_resv *resv, 91 bool shared) 92{ 93 struct dma_resv_list *flist; 94 struct dma_fence *f; 95 struct radeon_fence *fence; 96 unsigned i; 97 int r = 0; 98 99 /* always sync to the exclusive fence */ 100 f = dma_resv_get_excl(resv); 101 fence = f ? to_radeon_fence(f) : NULL; 102 if (fence && fence->rdev == rdev) 103 radeon_sync_fence(sync, fence); 104 else if (f) 105 r = dma_fence_wait(f, true); 106 107 flist = dma_resv_get_list(resv); 108 if (shared || !flist || r) 109 return r; 110 111 for (i = 0; i < flist->shared_count; ++i) { 112 f = rcu_dereference_protected(flist->shared[i], 113 dma_resv_held(resv)); 114 fence = to_radeon_fence(f); 115 if (fence && fence->rdev == rdev) 116 radeon_sync_fence(sync, fence); 117 else 118 r = dma_fence_wait(f, true); 119 120 if (r) 121 break; 122 } 123 return r; 124} 125 126/** 127 * radeon_sync_rings - sync ring to all registered fences 128 * 129 * @rdev: radeon_device pointer 130 * @sync: sync object to use 131 * @ring: ring that needs sync 132 * 133 * Ensure that all registered fences are signaled before letting 134 * the ring continue. The caller must hold the ring lock. 135 */ 136int radeon_sync_rings(struct radeon_device *rdev, 137 struct radeon_sync *sync, 138 int ring) 139{ 140 unsigned count = 0; 141 int i, r; 142 143 for (i = 0; i < RADEON_NUM_RINGS; ++i) { 144 struct radeon_fence *fence = sync->sync_to[i]; 145 struct radeon_semaphore *semaphore; 146 147 /* check if we really need to sync */ 148 if (!radeon_fence_need_sync(fence, ring)) 149 continue; 150 151 /* prevent GPU deadlocks */ 152 if (!rdev->ring[i].ready) { 153 dev_err(rdev->dev, "Syncing to a disabled ring!"); 154 return -EINVAL; 155 } 156 157 if (count >= RADEON_NUM_SYNCS) { 158 /* not enough room, wait manually */ 159 r = radeon_fence_wait(fence, false); 160 if (r) 161 return r; 162 continue; 163 } 164 r = radeon_semaphore_create(rdev, &semaphore); 165 if (r) 166 return r; 167 168 sync->semaphores[count++] = semaphore; 169 170 /* allocate enough space for sync command */ 171 r = radeon_ring_alloc(rdev, &rdev->ring[i], 16); 172 if (r) 173 return r; 174 175 /* emit the signal semaphore */ 176 if (!radeon_semaphore_emit_signal(rdev, i, semaphore)) { 177 /* signaling wasn't successful wait manually */ 178 radeon_ring_undo(&rdev->ring[i]); 179 r = radeon_fence_wait(fence, false); 180 if (r) 181 return r; 182 continue; 183 } 184 185 /* we assume caller has already allocated space on waiters ring */ 186 if (!radeon_semaphore_emit_wait(rdev, ring, semaphore)) { 187 /* waiting wasn't successful wait manually */ 188 radeon_ring_undo(&rdev->ring[i]); 189 r = radeon_fence_wait(fence, false); 190 if (r) 191 return r; 192 continue; 193 } 194 195 radeon_ring_commit(rdev, &rdev->ring[i], false); 196 radeon_fence_note_sync(fence, ring); 197 } 198 199 return 0; 200} 201 202/** 203 * radeon_sync_free - free the sync object 204 * 205 * @rdev: radeon_device pointer 206 * @sync: sync object to use 207 * @fence: fence to use for the free 208 * 209 * Free the sync object by freeing all semaphores in it. 210 */ 211void radeon_sync_free(struct radeon_device *rdev, 212 struct radeon_sync *sync, 213 struct radeon_fence *fence) 214{ 215 unsigned i; 216 217 for (i = 0; i < RADEON_NUM_SYNCS; ++i) 218 radeon_semaphore_free(rdev, &sync->semaphores[i], fence); 219} 220