drm: base prime/dma-buf support (v5)
[linux-2.6.git] / drivers / gpu / drm / drm_prime.c
1 /*
2  * Copyright © 2012 Red Hat
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 (including the next
12  * paragraph) shall be included in all copies or substantial portions of the
13  * Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21  * IN THE SOFTWARE.
22  *
23  * Authors:
24  *      Dave Airlie <airlied@redhat.com>
25  *      Rob Clark <rob.clark@linaro.org>
26  *
27  */
28
29 #include <linux/export.h>
30 #include <linux/dma-buf.h>
31 #include "drmP.h"
32
33 /*
34  * DMA-BUF/GEM Object references and lifetime overview:
35  *
36  * On the export the dma_buf holds a reference to the exporting GEM
37  * object. It takes this reference in handle_to_fd_ioctl, when it
38  * first calls .prime_export and stores the exporting GEM object in
39  * the dma_buf priv. This reference is released when the dma_buf
40  * object goes away in the driver .release function.
41  *
42  * On the import the importing GEM object holds a reference to the
43  * dma_buf (which in turn holds a ref to the exporting GEM object).
44  * It takes that reference in the fd_to_handle ioctl.
45  * It calls dma_buf_get, creates an attachment to it and stores the
46  * attachment in the GEM object. When this attachment is destroyed
47  * when the imported object is destroyed, we remove the attachment
48  * and drop the reference to the dma_buf.
49  *
50  * Thus the chain of references always flows in one direction
51  * (avoiding loops): importing_gem -> dmabuf -> exporting_gem
52  *
53  * Self-importing: if userspace is using PRIME as a replacement for flink
54  * then it will get a fd->handle request for a GEM object that it created.
55  * Drivers should detect this situation and return back the gem object
56  * from the dma-buf private.
57  */
58
59 struct drm_prime_member {
60         struct list_head entry;
61         struct dma_buf *dma_buf;
62         uint32_t handle;
63 };
64
65 int drm_gem_prime_handle_to_fd(struct drm_device *dev,
66                 struct drm_file *file_priv, uint32_t handle, uint32_t flags,
67                 int *prime_fd)
68 {
69         struct drm_gem_object *obj;
70         void *buf;
71
72         obj = drm_gem_object_lookup(dev, file_priv, handle);
73         if (!obj)
74                 return -ENOENT;
75
76         mutex_lock(&file_priv->prime.lock);
77         /* re-export the original imported object */
78         if (obj->import_attach) {
79                 get_dma_buf(obj->import_attach->dmabuf);
80                 *prime_fd = dma_buf_fd(obj->import_attach->dmabuf, flags);
81                 drm_gem_object_unreference_unlocked(obj);
82                 mutex_unlock(&file_priv->prime.lock);
83                 return 0;
84         }
85
86         if (obj->export_dma_buf) {
87                 get_dma_buf(obj->export_dma_buf);
88                 *prime_fd = dma_buf_fd(obj->export_dma_buf, flags);
89                 drm_gem_object_unreference_unlocked(obj);
90         } else {
91                 buf = dev->driver->gem_prime_export(dev, obj, flags);
92                 if (IS_ERR(buf)) {
93                         /* normally the created dma-buf takes ownership of the ref,
94                          * but if that fails then drop the ref
95                          */
96                         drm_gem_object_unreference_unlocked(obj);
97                         mutex_unlock(&file_priv->prime.lock);
98                         return PTR_ERR(buf);
99                 }
100                 obj->export_dma_buf = buf;
101                 *prime_fd = dma_buf_fd(buf, flags);
102         }
103         mutex_unlock(&file_priv->prime.lock);
104         return 0;
105 }
106 EXPORT_SYMBOL(drm_gem_prime_handle_to_fd);
107
108 int drm_gem_prime_fd_to_handle(struct drm_device *dev,
109                 struct drm_file *file_priv, int prime_fd, uint32_t *handle)
110 {
111         struct dma_buf *dma_buf;
112         struct drm_gem_object *obj;
113         int ret;
114
115         dma_buf = dma_buf_get(prime_fd);
116         if (IS_ERR(dma_buf))
117                 return PTR_ERR(dma_buf);
118
119         mutex_lock(&file_priv->prime.lock);
120
121         ret = drm_prime_lookup_imported_buf_handle(&file_priv->prime,
122                         dma_buf, handle);
123         if (!ret) {
124                 ret = 0;
125                 goto out_put;
126         }
127
128         /* never seen this one, need to import */
129         obj = dev->driver->gem_prime_import(dev, dma_buf);
130         if (IS_ERR(obj)) {
131                 ret = PTR_ERR(obj);
132                 goto out_put;
133         }
134
135         ret = drm_gem_handle_create(file_priv, obj, handle);
136         drm_gem_object_unreference_unlocked(obj);
137         if (ret)
138                 goto out_put;
139
140         ret = drm_prime_add_imported_buf_handle(&file_priv->prime,
141                         dma_buf, *handle);
142         if (ret)
143                 goto fail;
144
145         mutex_unlock(&file_priv->prime.lock);
146         return 0;
147
148 fail:
149         /* hmm, if driver attached, we are relying on the free-object path
150          * to detach.. which seems ok..
151          */
152         drm_gem_object_handle_unreference_unlocked(obj);
153 out_put:
154         dma_buf_put(dma_buf);
155         mutex_unlock(&file_priv->prime.lock);
156         return ret;
157 }
158 EXPORT_SYMBOL(drm_gem_prime_fd_to_handle);
159
160 int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data,
161                                  struct drm_file *file_priv)
162 {
163         struct drm_prime_handle *args = data;
164         uint32_t flags;
165
166         if (!drm_core_check_feature(dev, DRIVER_PRIME))
167                 return -EINVAL;
168
169         if (!dev->driver->prime_handle_to_fd)
170                 return -ENOSYS;
171
172         /* check flags are valid */
173         if (args->flags & ~DRM_CLOEXEC)
174                 return -EINVAL;
175
176         /* we only want to pass DRM_CLOEXEC which is == O_CLOEXEC */
177         flags = args->flags & DRM_CLOEXEC;
178
179         return dev->driver->prime_handle_to_fd(dev, file_priv,
180                         args->handle, flags, &args->fd);
181 }
182
183 int drm_prime_fd_to_handle_ioctl(struct drm_device *dev, void *data,
184                                  struct drm_file *file_priv)
185 {
186         struct drm_prime_handle *args = data;
187
188         if (!drm_core_check_feature(dev, DRIVER_PRIME))
189                 return -EINVAL;
190
191         if (!dev->driver->prime_fd_to_handle)
192                 return -ENOSYS;
193
194         return dev->driver->prime_fd_to_handle(dev, file_priv,
195                         args->fd, &args->handle);
196 }
197
198 /*
199  * drm_prime_pages_to_sg
200  *
201  * this helper creates an sg table object from a set of pages
202  * the driver is responsible for mapping the pages into the
203  * importers address space
204  */
205 struct sg_table *drm_prime_pages_to_sg(struct page **pages, int nr_pages)
206 {
207         struct sg_table *sg = NULL;
208         struct scatterlist *iter;
209         int i;
210         int ret;
211
212         sg = kmalloc(sizeof(struct sg_table), GFP_KERNEL);
213         if (!sg)
214                 goto out;
215
216         ret = sg_alloc_table(sg, nr_pages, GFP_KERNEL);
217         if (ret)
218                 goto out;
219
220         for_each_sg(sg->sgl, iter, nr_pages, i)
221                 sg_set_page(iter, pages[i], PAGE_SIZE, 0);
222
223         return sg;
224 out:
225         kfree(sg);
226         return NULL;
227 }
228 EXPORT_SYMBOL(drm_prime_pages_to_sg);
229
230 /* helper function to cleanup a GEM/prime object */
231 void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg)
232 {
233         struct dma_buf_attachment *attach;
234         struct dma_buf *dma_buf;
235         attach = obj->import_attach;
236         if (sg)
237                 dma_buf_unmap_attachment(attach, sg, DMA_BIDIRECTIONAL);
238         dma_buf = attach->dmabuf;
239         dma_buf_detach(attach->dmabuf, attach);
240         /* remove the reference */
241         dma_buf_put(dma_buf);
242 }
243 EXPORT_SYMBOL(drm_prime_gem_destroy);
244
245 void drm_prime_init_file_private(struct drm_prime_file_private *prime_fpriv)
246 {
247         INIT_LIST_HEAD(&prime_fpriv->head);
248         mutex_init(&prime_fpriv->lock);
249 }
250 EXPORT_SYMBOL(drm_prime_init_file_private);
251
252 void drm_prime_destroy_file_private(struct drm_prime_file_private *prime_fpriv)
253 {
254         struct drm_prime_member *member, *safe;
255         list_for_each_entry_safe(member, safe, &prime_fpriv->head, entry) {
256                 list_del(&member->entry);
257                 kfree(member);
258         }
259 }
260 EXPORT_SYMBOL(drm_prime_destroy_file_private);
261
262 int drm_prime_add_imported_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf, uint32_t handle)
263 {
264         struct drm_prime_member *member;
265
266         member = kmalloc(sizeof(*member), GFP_KERNEL);
267         if (!member)
268                 return -ENOMEM;
269
270         member->dma_buf = dma_buf;
271         member->handle = handle;
272         list_add(&member->entry, &prime_fpriv->head);
273         return 0;
274 }
275 EXPORT_SYMBOL(drm_prime_add_imported_buf_handle);
276
277 int drm_prime_lookup_imported_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf, uint32_t *handle)
278 {
279         struct drm_prime_member *member;
280
281         list_for_each_entry(member, &prime_fpriv->head, entry) {
282                 if (member->dma_buf == dma_buf) {
283                         *handle = member->handle;
284                         return 0;
285                 }
286         }
287         return -ENOENT;
288 }
289 EXPORT_SYMBOL(drm_prime_lookup_imported_buf_handle);
290
291 void drm_prime_remove_imported_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf)
292 {
293         struct drm_prime_member *member, *safe;
294
295         mutex_lock(&prime_fpriv->lock);
296         list_for_each_entry_safe(member, safe, &prime_fpriv->head, entry) {
297                 if (member->dma_buf == dma_buf) {
298                         list_del(&member->entry);
299                         kfree(member);
300                 }
301         }
302         mutex_unlock(&prime_fpriv->lock);
303 }
304 EXPORT_SYMBOL(drm_prime_remove_imported_buf_handle);