1 /* 2 * Copyright 2015 Advanced Micro Devices, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 */ 23 24 #include <linux/kthread.h> 25 #include <linux/wait.h> 26 #include <linux/sched.h> 27 #include <drm/drmP.h> 28 #include <drm/gpu_scheduler.h> 29 30 static struct pool sched_fence_slab; 31 32 int __init drm_sched_fence_slab_init(void) 33 { 34 #ifdef __linux__ 35 sched_fence_slab = kmem_cache_create( 36 "drm_sched_fence", sizeof(struct drm_sched_fence), 0, 37 SLAB_HWCACHE_ALIGN, NULL); 38 if (!sched_fence_slab) 39 return -ENOMEM; 40 #else 41 pool_init(&sched_fence_slab, sizeof(struct drm_sched_fence), 42 0, IPL_NONE, 0, "drm_sched_fence", NULL); 43 #endif 44 45 return 0; 46 } 47 48 void __exit drm_sched_fence_slab_fini(void) 49 { 50 rcu_barrier(); 51 #ifdef __linux__ 52 kmem_cache_destroy(sched_fence_slab); 53 #else 54 pool_destroy(&sched_fence_slab); 55 #endif 56 } 57 58 void drm_sched_fence_scheduled(struct drm_sched_fence *fence) 59 { 60 int ret = dma_fence_signal(&fence->scheduled); 61 62 if (!ret) 63 DMA_FENCE_TRACE(&fence->scheduled, 64 "signaled from irq context\n"); 65 else 66 DMA_FENCE_TRACE(&fence->scheduled, 67 "was already signaled\n"); 68 } 69 70 void drm_sched_fence_finished(struct drm_sched_fence *fence) 71 { 72 int ret = dma_fence_signal(&fence->finished); 73 74 if (!ret) 75 DMA_FENCE_TRACE(&fence->finished, 76 "signaled from irq context\n"); 77 else 78 DMA_FENCE_TRACE(&fence->finished, 79 "was already signaled\n"); 80 } 81 82 static const char *drm_sched_fence_get_driver_name(struct dma_fence *fence) 83 { 84 return "drm_sched"; 85 } 86 87 static const char *drm_sched_fence_get_timeline_name(struct dma_fence *f) 88 { 89 struct drm_sched_fence *fence = to_drm_sched_fence(f); 90 return (const char *)fence->sched->name; 91 } 92 93 /** 94 * drm_sched_fence_free - free up the fence memory 95 * 96 * @rcu: RCU callback head 97 * 98 * Free up the fence memory after the RCU grace period. 99 */ 100 static void drm_sched_fence_free(struct rcu_head *rcu) 101 { 102 struct dma_fence *f = container_of(rcu, struct dma_fence, rcu); 103 struct drm_sched_fence *fence = to_drm_sched_fence(f); 104 105 #ifdef __linux__ 106 kmem_cache_free(sched_fence_slab, fence); 107 #else 108 pool_put(&sched_fence_slab, fence); 109 #endif 110 } 111 112 /** 113 * drm_sched_fence_release_scheduled - callback that fence can be freed 114 * 115 * @fence: fence 116 * 117 * This function is called when the reference count becomes zero. 118 * It just RCU schedules freeing up the fence. 119 */ 120 static void drm_sched_fence_release_scheduled(struct dma_fence *f) 121 { 122 struct drm_sched_fence *fence = to_drm_sched_fence(f); 123 124 dma_fence_put(fence->parent); 125 call_rcu(&fence->finished.rcu, drm_sched_fence_free); 126 } 127 128 /** 129 * drm_sched_fence_release_finished - drop extra reference 130 * 131 * @f: fence 132 * 133 * Drop the extra reference from the scheduled fence to the base fence. 134 */ 135 static void drm_sched_fence_release_finished(struct dma_fence *f) 136 { 137 struct drm_sched_fence *fence = to_drm_sched_fence(f); 138 139 dma_fence_put(&fence->scheduled); 140 } 141 142 const struct dma_fence_ops drm_sched_fence_ops_scheduled = { 143 .get_driver_name = drm_sched_fence_get_driver_name, 144 .get_timeline_name = drm_sched_fence_get_timeline_name, 145 .release = drm_sched_fence_release_scheduled, 146 }; 147 148 const struct dma_fence_ops drm_sched_fence_ops_finished = { 149 .get_driver_name = drm_sched_fence_get_driver_name, 150 .get_timeline_name = drm_sched_fence_get_timeline_name, 151 .release = drm_sched_fence_release_finished, 152 }; 153 154 struct drm_sched_fence *to_drm_sched_fence(struct dma_fence *f) 155 { 156 if (f->ops == &drm_sched_fence_ops_scheduled) 157 return container_of(f, struct drm_sched_fence, scheduled); 158 159 if (f->ops == &drm_sched_fence_ops_finished) 160 return container_of(f, struct drm_sched_fence, finished); 161 162 return NULL; 163 } 164 EXPORT_SYMBOL(to_drm_sched_fence); 165 166 struct drm_sched_fence *drm_sched_fence_create(struct drm_sched_entity *entity, 167 void *owner) 168 { 169 struct drm_sched_fence *fence = NULL; 170 unsigned seq; 171 172 #ifdef __linux__ 173 fence = kmem_cache_zalloc(sched_fence_slab, GFP_KERNEL); 174 #else 175 fence = pool_get(&sched_fence_slab, PR_WAITOK | PR_ZERO); 176 #endif 177 if (fence == NULL) 178 return NULL; 179 180 fence->owner = owner; 181 fence->sched = entity->rq->sched; 182 mtx_init(&fence->lock, IPL_TTY); 183 184 seq = atomic_inc_return(&entity->fence_seq); 185 dma_fence_init(&fence->scheduled, &drm_sched_fence_ops_scheduled, 186 &fence->lock, entity->fence_context, seq); 187 dma_fence_init(&fence->finished, &drm_sched_fence_ops_finished, 188 &fence->lock, entity->fence_context + 1, seq); 189 190 return fence; 191 } 192 193 module_init(drm_sched_fence_slab_init); 194 module_exit(drm_sched_fence_slab_fini); 195 196 MODULE_DESCRIPTION("DRM GPU scheduler"); 197 MODULE_LICENSE("GPL and additional rights"); 198