tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * Copyright (C) 2013-2016 Red Hat
3 * Author: Rob Clark <robdclark@gmail.com>
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18#include <linux/dma-fence.h>
19
20#include "msm_drv.h"
21#include "msm_fence.h"
22
23
24struct msm_fence_context *
25msm_fence_context_alloc(struct drm_device *dev, const char *name)
26{
27 struct msm_fence_context *fctx;
28
29 fctx = kzalloc(sizeof(*fctx), GFP_KERNEL);
30 if (!fctx)
31 return ERR_PTR(-ENOMEM);
32
33 fctx->dev = dev;
34 strncpy(fctx->name, name, sizeof(fctx->name));
35 fctx->context = dma_fence_context_alloc(1);
36 init_waitqueue_head(&fctx->event);
37 spin_lock_init(&fctx->spinlock);
38
39 return fctx;
40}
41
42void msm_fence_context_free(struct msm_fence_context *fctx)
43{
44 kfree(fctx);
45}
46
47static inline bool fence_completed(struct msm_fence_context *fctx, uint32_t fence)
48{
49 return (int32_t)(fctx->completed_fence - fence) >= 0;
50}
51
52/* legacy path for WAIT_FENCE ioctl: */
53int msm_wait_fence(struct msm_fence_context *fctx, uint32_t fence,
54 ktime_t *timeout, bool interruptible)
55{
56 int ret;
57
58 if (fence > fctx->last_fence) {
59 DRM_ERROR("%s: waiting on invalid fence: %u (of %u)\n",
60 fctx->name, fence, fctx->last_fence);
61 return -EINVAL;
62 }
63
64 if (!timeout) {
65 /* no-wait: */
66 ret = fence_completed(fctx, fence) ? 0 : -EBUSY;
67 } else {
68 unsigned long remaining_jiffies = timeout_to_jiffies(timeout);
69
70 if (interruptible)
71 ret = wait_event_interruptible_timeout(fctx->event,
72 fence_completed(fctx, fence),
73 remaining_jiffies);
74 else
75 ret = wait_event_timeout(fctx->event,
76 fence_completed(fctx, fence),
77 remaining_jiffies);
78
79 if (ret == 0) {
80 DBG("timeout waiting for fence: %u (completed: %u)",
81 fence, fctx->completed_fence);
82 ret = -ETIMEDOUT;
83 } else if (ret != -ERESTARTSYS) {
84 ret = 0;
85 }
86 }
87
88 return ret;
89}
90
91/* called from workqueue */
92void msm_update_fence(struct msm_fence_context *fctx, uint32_t fence)
93{
94 spin_lock(&fctx->spinlock);
95 fctx->completed_fence = max(fence, fctx->completed_fence);
96 spin_unlock(&fctx->spinlock);
97
98 wake_up_all(&fctx->event);
99}
100
101struct msm_fence {
102 struct dma_fence base;
103 struct msm_fence_context *fctx;
104};
105
106static inline struct msm_fence *to_msm_fence(struct dma_fence *fence)
107{
108 return container_of(fence, struct msm_fence, base);
109}
110
111static const char *msm_fence_get_driver_name(struct dma_fence *fence)
112{
113 return "msm";
114}
115
116static const char *msm_fence_get_timeline_name(struct dma_fence *fence)
117{
118 struct msm_fence *f = to_msm_fence(fence);
119 return f->fctx->name;
120}
121
122static bool msm_fence_signaled(struct dma_fence *fence)
123{
124 struct msm_fence *f = to_msm_fence(fence);
125 return fence_completed(f->fctx, f->base.seqno);
126}
127
128static const struct dma_fence_ops msm_fence_ops = {
129 .get_driver_name = msm_fence_get_driver_name,
130 .get_timeline_name = msm_fence_get_timeline_name,
131 .signaled = msm_fence_signaled,
132};
133
134struct dma_fence *
135msm_fence_alloc(struct msm_fence_context *fctx)
136{
137 struct msm_fence *f;
138
139 f = kzalloc(sizeof(*f), GFP_KERNEL);
140 if (!f)
141 return ERR_PTR(-ENOMEM);
142
143 f->fctx = fctx;
144
145 dma_fence_init(&f->base, &msm_fence_ops, &fctx->spinlock,
146 fctx->context, ++fctx->last_fence);
147
148 return &f->base;
149}