1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Syncpoint dma_fence implementation 4 * 5 * Copyright (c) 2020, NVIDIA Corporation. 6 */ 7 8 #include <linux/dma-fence.h> 9 #include <linux/file.h> 10 #include <linux/fs.h> 11 #include <linux/slab.h> 12 #include <linux/sync_file.h> 13 14 #include "fence.h" 15 #include "intr.h" 16 #include "syncpt.h" 17 18 static const char *host1x_syncpt_fence_get_driver_name(struct dma_fence *f) 19 { 20 return "host1x"; 21 } 22 23 static const char *host1x_syncpt_fence_get_timeline_name(struct dma_fence *f) 24 { 25 return "syncpoint"; 26 } 27 28 static struct host1x_syncpt_fence *to_host1x_fence(struct dma_fence *f) 29 { 30 return container_of(f, struct host1x_syncpt_fence, base); 31 } 32 33 static bool host1x_syncpt_fence_enable_signaling(struct dma_fence *f) 34 { 35 struct host1x_syncpt_fence *sf = to_host1x_fence(f); 36 37 if (host1x_syncpt_is_expired(sf->sp, sf->threshold)) 38 return false; 39 40 /* Reference for interrupt path. */ 41 dma_fence_get(f); 42 43 /* 44 * The dma_fence framework requires the fence driver to keep a 45 * reference to any fences for which 'enable_signaling' has been 46 * called (and that have not been signalled). 47 * 48 * We cannot currently always guarantee that all fences get signalled 49 * or cancelled. As such, for such situations, set up a timeout, so 50 * that long-lasting fences will get reaped eventually. 51 */ 52 if (sf->timeout) { 53 /* Reference for timeout path. */ 54 dma_fence_get(f); 55 schedule_delayed_work(&sf->timeout_work, msecs_to_jiffies(30000)); 56 } 57 58 host1x_intr_add_fence_locked(sf->sp->host, sf); 59 60 /* 61 * The fence may get signalled at any time after the above call, 62 * so we need to initialize all state used by signalling 63 * before it. 64 */ 65 66 return true; 67 } 68 69 static const struct dma_fence_ops host1x_syncpt_fence_ops = { 70 .get_driver_name = host1x_syncpt_fence_get_driver_name, 71 .get_timeline_name = host1x_syncpt_fence_get_timeline_name, 72 .enable_signaling = host1x_syncpt_fence_enable_signaling, 73 }; 74 75 void host1x_fence_signal(struct host1x_syncpt_fence *f) 76 { 77 if (atomic_xchg(&f->signaling, 1)) { 78 /* 79 * Already on timeout path, but we removed the fence before 80 * timeout path could, so drop interrupt path reference. 81 */ 82 dma_fence_put(&f->base); 83 return; 84 } 85 86 if (f->timeout && cancel_delayed_work(&f->timeout_work)) { 87 /* 88 * We know that the timeout path will not be entered. 89 * Safe to drop the timeout path's reference now. 90 */ 91 dma_fence_put(&f->base); 92 } 93 94 dma_fence_signal_locked(&f->base); 95 dma_fence_put(&f->base); 96 } 97 98 static void do_fence_timeout(struct work_struct *work) 99 { 100 struct delayed_work *dwork = (struct delayed_work *)work; 101 struct host1x_syncpt_fence *f = 102 container_of(dwork, struct host1x_syncpt_fence, timeout_work); 103 104 if (atomic_xchg(&f->signaling, 1)) { 105 /* Already on interrupt path, drop timeout path reference if any. */ 106 if (f->timeout) 107 dma_fence_put(&f->base); 108 return; 109 } 110 111 if (host1x_intr_remove_fence(f->sp->host, f)) { 112 /* 113 * Managed to remove fence from queue, so it's safe to drop 114 * the interrupt path's reference. 115 */ 116 dma_fence_put(&f->base); 117 } 118 119 dma_fence_set_error(&f->base, -ETIMEDOUT); 120 dma_fence_signal(&f->base); 121 if (f->timeout) 122 dma_fence_put(&f->base); 123 } 124 125 struct dma_fence *host1x_fence_create(struct host1x_syncpt *sp, u32 threshold, 126 bool timeout) 127 { 128 struct host1x_syncpt_fence *fence; 129 130 fence = kzalloc_obj(*fence); 131 if (!fence) 132 return ERR_PTR(-ENOMEM); 133 134 fence->sp = sp; 135 fence->threshold = threshold; 136 fence->timeout = timeout; 137 138 dma_fence_init(&fence->base, &host1x_syncpt_fence_ops, &sp->fences.lock, 139 dma_fence_context_alloc(1), 0); 140 141 INIT_DELAYED_WORK(&fence->timeout_work, do_fence_timeout); 142 143 return &fence->base; 144 } 145 EXPORT_SYMBOL(host1x_fence_create); 146 147 void host1x_fence_cancel(struct dma_fence *f) 148 { 149 struct host1x_syncpt_fence *sf = to_host1x_fence(f); 150 151 schedule_delayed_work(&sf->timeout_work, 0); 152 flush_delayed_work(&sf->timeout_work); 153 } 154 EXPORT_SYMBOL(host1x_fence_cancel); 155 156 /** 157 * host1x_fence_extract() - extract underlying syncpoint/threshold from fence 158 * @fence: fence to extract information from 159 * @host1x: out pointer for host1x instance corresponding to the syncpoint 160 * @id: out pointer for the syncpoint ID the fence pends on 161 * @threshold: out pointer for the syncpoint value the fence pends on 162 * 163 * Extracts underlying host1x hardware related information from a host1x 164 * syncpoint fence. This information can be used by devices that have direct 165 * access to host1x syncpoints to wait the fence in hardware without CPU 166 * interaction. 167 * 168 * A system might have multiple instances of host1x with separate sets of 169 * syncpoints. Callers must ensure any hardware that is programmed is accessing 170 * the correct set of syncpoints as identified by @host1x. 171 * 172 * Note that a fence that has already signalled may no longer be identifiable as 173 * a syncpoint fence, as the dma_fence framework can detach fence ops on 174 * signalled fences. 175 * 176 * Returns 0 on success, or -EINVAL if @fence is not a syncpoint fence. 177 */ 178 int host1x_fence_extract(struct dma_fence *fence, struct host1x **host1x, 179 u32 *id, u32 *threshold) 180 { 181 struct host1x_syncpt_fence *f; 182 183 if (rcu_access_pointer(fence->ops) != &host1x_syncpt_fence_ops) 184 return -EINVAL; 185 186 f = to_host1x_fence(fence); 187 188 if (host1x) 189 *host1x = f->sp->host; 190 if (id) 191 *id = f->sp->id; 192 if (threshold) 193 *threshold = f->threshold; 194 195 return 0; 196 } 197 EXPORT_SYMBOL(host1x_fence_extract); 198