← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-ti-omap4/quantal-proposed

« back to all changes in this revision

Viewing changes to drivers/gpu/drm/drm_prime.c

  • Committer: Package Import Robot
  • Author(s): Brad Figg, Brad Figg
  • Date: 2013-06-08 09:09:23 UTC
  • Revision ID: package-import@ubuntu.com-20130608090923-ibtnp6edtrn3sxik
Tags: 3.5.0-226.39
[ Brad Figg ]

UBUNTU: Fixup missing abi files causing FTBS

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/gpu/drm/drm_prime.c
61
61
        struct dma_buf *dma_buf;
62
62
        uint32_t handle;
63
63
};
 
64
static int drm_prime_add_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf, uint32_t handle);
64
65
 
65
66
int drm_gem_prime_handle_to_fd(struct drm_device *dev,
66
67
                struct drm_file *file_priv, uint32_t handle, uint32_t flags,
68
69
{
69
70
        struct drm_gem_object *obj;
70
71
        void *buf;
71
 
        int ret;
 
72
        int ret = 0;
 
73
        struct dma_buf *dmabuf;
72
74
 
73
75
        obj = drm_gem_object_lookup(dev, file_priv, handle);
74
76
        if (!obj)
77
79
        mutex_lock(&file_priv->prime.lock);
78
80
        /* re-export the original imported object */
79
81
        if (obj->import_attach) {
80
 
                get_dma_buf(obj->import_attach->dmabuf);
81
 
                *prime_fd = dma_buf_fd(obj->import_attach->dmabuf, flags);
82
 
                drm_gem_object_unreference_unlocked(obj);
83
 
                mutex_unlock(&file_priv->prime.lock);
84
 
                return 0;
85
 
        }
86
 
 
87
 
        mutex_lock(&dev->prime_lock);
88
 
        if (obj->dma_buf) {
89
 
                get_dma_buf(obj->dma_buf);
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
 
                        ret = PTR_ERR(buf);
97
 
                        goto out;
98
 
                }
99
 
                /* Allocate a reference for the dma buf. */
100
 
                drm_gem_object_reference(obj);
101
 
 
102
 
                /* Allocate a reference for the re-export cache. */
103
 
                get_dma_buf(buf);
104
 
                obj->dma_buf = buf;
105
 
        }
 
82
                dmabuf = obj->import_attach->dmabuf;
 
83
                goto out_have_obj;
 
84
        }
 
85
 
 
86
        if (obj->export_dma_buf) {
 
87
                dmabuf = obj->export_dma_buf;
 
88
                goto out_have_obj;
 
89
        }
 
90
 
 
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
                ret = PTR_ERR(buf);
 
97
                goto out;
 
98
        }
 
99
        obj->export_dma_buf = buf;
 
100
 
106
101
        /* if we've exported this buffer the cheat and add it to the import list
107
102
         * so we get the correct handle back
108
103
         */
109
 
        ret = drm_prime_add_imported_buf_handle(&file_priv->prime,
110
 
                        obj->dma_buf, handle);
 
104
        ret = drm_prime_add_buf_handle(&file_priv->prime,
 
105
                                       obj->export_dma_buf, handle);
111
106
        if (ret)
112
107
                goto out;
113
108
 
114
 
        /* Only set up the userspace fd once everything is done. */
115
 
        *prime_fd = dma_buf_fd(obj->dma_buf, flags);
 
109
        *prime_fd = dma_buf_fd(buf, flags);
 
110
        mutex_unlock(&file_priv->prime.lock);
 
111
        return 0;
 
112
 
 
113
out_have_obj:
 
114
        get_dma_buf(dmabuf);
 
115
        *prime_fd = dma_buf_fd(dmabuf, flags);
116
116
out:
117
 
        mutex_unlock(&dev->prime_lock);
118
 
        mutex_unlock(&file_priv->prime.lock);
119
 
 
120
 
        /* Check whether someone sneaky dropped the last userspace gem handle,
121
 
         * clean up the mess if so. */
122
 
        if (atomic_read(&obj->handle_count) == 0)
123
 
                drm_gem_object_handle_free(obj);
124
 
 
125
117
        drm_gem_object_unreference_unlocked(obj);
126
 
 
 
118
        mutex_unlock(&file_priv->prime.lock);
127
119
        return ret;
128
120
}
129
121
EXPORT_SYMBOL(drm_gem_prime_handle_to_fd);
141
133
 
142
134
        mutex_lock(&file_priv->prime.lock);
143
135
 
144
 
        ret = drm_prime_lookup_imported_buf_handle(&file_priv->prime,
 
136
        ret = drm_prime_lookup_buf_handle(&file_priv->prime,
145
137
                        dma_buf, handle);
146
138
        if (!ret) {
147
 
                mutex_unlock(&file_priv->prime.lock);
148
 
                dma_buf_put(dma_buf);
149
 
 
150
 
                return 0;
 
139
                ret = 0;
 
140
                goto out_put;
151
141
        }
152
142
 
153
143
        /* never seen this one, need to import */
154
144
        obj = dev->driver->gem_prime_import(dev, dma_buf);
155
145
        if (IS_ERR(obj)) {
156
 
                mutex_unlock(&file_priv->prime.lock);
157
 
                dma_buf_put(dma_buf);
158
 
 
159
 
                return PTR_ERR(obj);
 
146
                ret = PTR_ERR(obj);
 
147
                goto out_put;
160
148
        }
161
149
 
162
 
        mutex_lock(&dev->prime_lock);
163
 
        /* Refill the export cache - this is only really important if the dma
164
 
         * buf was the only userspace visible handle left and we're re-importing
165
 
         * into the original exporter, in which case we've cleared obj->dma_buf
166
 
         * already. Because we will create a GEM userspace handle below we only
167
 
         * need to check for gem_close races if that fails.
168
 
         */
169
 
        if (!obj->dma_buf) {
170
 
                obj->dma_buf = dma_buf;
171
 
                get_dma_buf(dma_buf);
172
 
        } else
173
 
                WARN_ON(obj->dma_buf != dma_buf);
174
 
        mutex_unlock(&dev->prime_lock);
175
 
 
176
150
        ret = drm_gem_handle_create(file_priv, obj, handle);
 
151
        drm_gem_object_unreference_unlocked(obj);
177
152
        if (ret)
178
 
                goto fail_handle;
 
153
                goto out_put;
179
154
 
180
 
        ret = drm_prime_add_imported_buf_handle(&file_priv->prime,
 
155
        ret = drm_prime_add_buf_handle(&file_priv->prime,
181
156
                        dma_buf, *handle);
182
157
        if (ret)
183
158
                goto fail;
184
159
 
185
160
        mutex_unlock(&file_priv->prime.lock);
186
 
        drm_gem_object_unreference_unlocked(obj);
187
 
        dma_buf_put(dma_buf);
188
 
 
189
161
        return 0;
190
162
 
191
163
fail:
193
165
         * to detach.. which seems ok..
194
166
         */
195
167
        drm_gem_object_handle_unreference_unlocked(obj);
196
 
fail_handle:
197
 
        if (atomic_read(&obj->handle_count) == 0)
198
 
                drm_gem_object_handle_free(obj);
 
168
out_put:
 
169
        dma_buf_put(dma_buf);
199
170
        mutex_unlock(&file_priv->prime.lock);
200
 
        drm_gem_object_unreference_unlocked(obj);
201
 
        dma_buf_put(dma_buf);
202
 
 
203
171
        return ret;
204
172
}
205
173
EXPORT_SYMBOL(drm_gem_prime_fd_to_handle);
342
310
}
343
311
EXPORT_SYMBOL(drm_prime_destroy_file_private);
344
312
 
345
 
int drm_prime_add_imported_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf, uint32_t handle)
 
313
static int drm_prime_add_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf, uint32_t handle)
346
314
{
347
315
        struct drm_prime_member *member;
348
316
 
350
318
        if (!member)
351
319
                return -ENOMEM;
352
320
 
 
321
        get_dma_buf(dma_buf);
353
322
        member->dma_buf = dma_buf;
354
323
        member->handle = handle;
355
324
        list_add(&member->entry, &prime_fpriv->head);
356
325
        return 0;
357
326
}
358
 
EXPORT_SYMBOL(drm_prime_add_imported_buf_handle);
359
327
 
360
 
int drm_prime_lookup_imported_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf, uint32_t *handle)
 
328
int drm_prime_lookup_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf, uint32_t *handle)
361
329
{
362
330
        struct drm_prime_member *member;
363
331
 
369
337
        }
370
338
        return -ENOENT;
371
339
}
372
 
EXPORT_SYMBOL(drm_prime_lookup_imported_buf_handle);
 
340
EXPORT_SYMBOL(drm_prime_lookup_buf_handle);
373
341
 
374
 
void drm_prime_remove_imported_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf)
 
342
void drm_prime_remove_buf_handle(struct drm_prime_file_private *prime_fpriv, struct dma_buf *dma_buf)
375
343
{
376
344
        struct drm_prime_member *member, *safe;
377
345
 
378
346
        mutex_lock(&prime_fpriv->lock);
379
347
        list_for_each_entry_safe(member, safe, &prime_fpriv->head, entry) {
380
348
                if (member->dma_buf == dma_buf) {
 
349
                        dma_buf_put(dma_buf);
381
350
                        list_del(&member->entry);
382
351
                        kfree(member);
383
352
                }
384
353
        }
385
354
        mutex_unlock(&prime_fpriv->lock);
386
355
}
387
 
EXPORT_SYMBOL(drm_prime_remove_imported_buf_handle);
 
356
EXPORT_SYMBOL(drm_prime_remove_buf_handle);